Complete.Org: Mailing Lists: Archives: freeciv-dev: September 2004:
[Freeciv-Dev] (PR#10201) PATCH: generator characteristics evolution, bes
Home

[Freeciv-Dev] (PR#10201) PATCH: generator characteristics evolution, bes

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: undisclosed-recipients: ;
Subject: [Freeciv-Dev] (PR#10201) PATCH: generator characteristics evolution, best handled temperature and relief.
From: "Marcelo Burda" <mburda@xxxxxxxxx>
Date: Wed, 22 Sep 2004 08:37:13 -0700
Reply-to: rt@xxxxxxxxxxx

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

FIX: alltemperate bug in cvs 
diff -ruN -Xfreeciv/diff_ignore freeciv/common/map.h freeciv_/common/map.h
--- freeciv/common/map.h        2004-09-20 18:42:30.000000000 +0200
+++ freeciv_/common/map.h       2004-09-22 17:12:04.000000000 +0200
@@ -536,6 +536,30 @@
 
 #define cardinal_adjc_dir_iterate_end adjc_dirlist_iterate_end
 
+/****************************************************************************
+  This iterator behaves like adjc_iterate or cardinal_adjc_iterate depending
+  on the value of card_only.
+****************************************************************************/
+#define variable_adjc_iterate(center_x, center_y, x_itr, y_itr, card_only)  \
+{                                                                          \
+  enum direction8 *_dirlist;                                               \
+  int _total;                                                              \
+                                                                           \
+  if (card_only) {                                                         \
+    _dirlist = map.cardinal_dirs;                                          \
+    _total = map.num_cardinal_dirs;                                        \
+  } else {                                                                 \
+    _dirlist = map.valid_dirs;                                             \
+    _total = map.num_valid_dirs;                                           \
+  }                                                                        \
+                                                                           \
+  adjc_dirlist_iterate(center_x, center_y, x_itr, y_itr,                   \
+                      _dir, _dirlist, _total) {
+
+#define variable_adjc_iterate_end                                          \
+  } adjc_dirlist_iterate_end;                                              \
+}
+
 /* Iterate through all tiles adjacent to a tile using the given list of
  * directions.  dir_itr is the directional value, (center_x, center_y) is
  * the center tile (which must be normalized), and (x_itr, y_itr) is the
diff -ruN -Xfreeciv/diff_ignore freeciv/common/terrain.c 
freeciv_/common/terrain.c
--- freeciv/common/terrain.c    2004-09-09 23:32:20.000000000 +0200
+++ freeciv_/common/terrain.c   2004-09-22 17:12:04.000000000 +0200
@@ -131,31 +131,6 @@
 }
 
 /****************************************************************************
-  This iterator behaves like adjc_iterate or cardinal_adjc_iterate depending
-  on the value of card_only.
-****************************************************************************/
-#define variable_adjc_iterate(center_x, center_y, x_itr, y_itr, card_only)  \
-{                                                                          \
-  enum direction8 *_dirlist;                                               \
-  int _total;                                                              \
-                                                                           \
-  if (card_only) {                                                         \
-    _dirlist = map.cardinal_dirs;                                          \
-    _total = map.num_cardinal_dirs;                                        \
-  } else {                                                                 \
-    _dirlist = map.valid_dirs;                                             \
-    _total = map.num_valid_dirs;                                           \
-  }                                                                        \
-                                                                           \
-  adjc_dirlist_iterate(center_x, center_y, x_itr, y_itr,                   \
-                      _dir, _dirlist, _total) {
-
-#define variable_adjc_iterate_end                                          \
-  } adjc_dirlist_iterate_end;                                              \
-}
-
-
-/****************************************************************************
   Returns TRUE iff any adjacent tile contains the given terrain.
 ****************************************************************************/
 bool is_terrain_near_tile(int map_x, int map_y, Terrain_type_id t)
Les fichiers binaires freeciv/manual/civmanual et freeciv_/manual/civmanual 
sont différents.
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/characteristics.c 
freeciv_/server/generator/characteristics.c
--- freeciv/server/generator/characteristics.c  1970-01-01 01:00:00.000000000 
+0100
+++ freeciv_/server/generator/characteristics.c 2004-09-22 17:29:49.000000000 
+0200
@@ -0,0 +1,902 @@
+/********************************************************************** 
+   Copyright (C) 1996-2004  The Freeciv Project Team
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+***********************************************************************/
+#include "config.h"
+#include "log.h"
+#include "map.h"
+#include "rand.h"
+
+#include "utilities.h"
+#include "characteristics.h"
+#include "height_map.h"
+#include "mapgen_topology.h"
+
+#define RIVERS_MAXTRIES 32767
+enum river_map_type {RS_BLOCKED = 0, RS_RIVER = 1};
+
+static characteristic_type *characteristic_map;
+
+characteristic_type CM_TRUE, CM_FALSE;
+characteristic_type CM_FLAT, CM_HILLY, CM_ABRUPT,
+                    CM_NFLAT;
+characteristic_type CM_FROZEN, CM_COLD, CM_TEMPERATE, CM_TROPICAL,
+                    CM_NFROZEN,  CM_ALL, CM_NHOT, CM_HOT;
+characteristic_type CM_OCEANIC,  CM_WET, CM_MEDIUM, CM_DRY,
+                    CM_NWET, CM_NDRY;
+characteristic_type CM_RIVER;
+/**************************************************************************
+ return TRUE if initialized
+*************************************************************************/ 
+bool characteristics_are_initialized(void)
+{
+  return characteristic_map != NULL;
+}
+
+/****************************************************************************
+ create the map and initialize CM_XXX
+****************************************************************************/
+void create_characteristics(void)                               
+{                                                          
+  assert( !characteristics_are_initialized());                              
+  characteristic_map = fc_malloc (sizeof(characteristic_type) * MAX_MAP_INDEX);
+  whole_map_iterate_index(i) {
+    BV_CLR_ALL(characteristic_map[i]);
+    BV_SET(characteristic_map[i], CB_TRUE);
+  }whole_map_iterate_index_end;
+
+  
+  BV_CLR_ALL(CM_TRUE);
+  BV_SET(CM_TRUE, CB_TRUE);
+  BV_CLR_ALL(CM_FALSE);
+
+  /* initialize constant values of relief */
+  BV_CLR_ALL(CM_FLAT);
+  BV_SET(CM_FLAT, CB_FLAT);
+  BV_CLR_ALL(CM_HILLY);
+  BV_SET(CM_HILLY, CB_HILLY);
+  BV_CLR_ALL(CM_ABRUPT);
+  BV_SET(CM_ABRUPT, CB_ABRUPT);
+  BV_CLR_ALL(CM_NFLAT);
+  BV_SET(CM_NFLAT, CB_HILLY);
+  BV_SET(CM_NFLAT, CB_ABRUPT);
+
+  /* inizialize constant value of temperature */
+  BV_CLR_ALL(CM_FROZEN);
+  BV_SET(CM_FROZEN, CB_FROZEN);
+  BV_CLR_ALL(CM_COLD);
+  BV_SET(CM_COLD, CB_COLD);
+  BV_CLR_ALL(CM_TEMPERATE);
+  BV_SET(CM_TEMPERATE, CB_TEMPERATE);
+  BV_CLR_ALL(CM_TROPICAL);
+  BV_SET(CM_TROPICAL, CB_TROPICAL);
+
+  BV_CLR_ALL(CM_NFROZEN);
+  BV_SET(CM_NFROZEN, CB_COLD);
+  BV_SET(CM_NFROZEN, CB_TEMPERATE);
+  BV_SET(CM_NFROZEN, CB_TROPICAL);
+
+  BV_CLR_ALL(CM_ALL);
+  BV_SET(CM_ALL, CB_FROZEN);
+  BV_SET(CM_ALL, CB_COLD);
+  BV_SET(CM_ALL, CB_TEMPERATE);
+  BV_SET(CM_ALL, CB_TROPICAL);
+
+  BV_CLR_ALL(CM_NHOT);
+  BV_SET(CM_NHOT, CB_FROZEN);
+  BV_SET(CM_NHOT, CB_COLD);
+ 
+  BV_CLR_ALL(CM_HOT);
+  BV_SET(CM_HOT, CB_TEMPERATE);
+  BV_SET(CM_HOT, CB_TROPICAL);
+
+  BV_CLR_ALL(CM_OCEANIC);
+  BV_SET(CM_OCEANIC, CB_OCEANIC);
+  BV_CLR_ALL(CM_WET);
+  BV_SET(CM_WET, CB_WET);
+  BV_CLR_ALL(CM_MEDIUM);
+  BV_SET(CM_MEDIUM, CB_MEDIUM);
+  BV_CLR_ALL(CM_DRY);
+  BV_SET(CM_DRY, CB_DRY);
+
+  BV_CLR_ALL(CM_NWET);
+  BV_SET(CM_NWET, CB_MEDIUM);
+  BV_SET(CM_NWET, CB_DRY);
+
+  BV_CLR_ALL(CM_NDRY);
+  BV_SET(CM_NDRY, CB_MEDIUM);
+  BV_SET(CM_NDRY, CB_WET);
+  
+  BV_CLR_ALL(CM_RIVER);
+  BV_SET(CM_RIVER, CB_RIVER);
+
+}
+
+/**************************************************************************** 
+  Free the map
+****************************************************************************/
+void destroy_characteristics(void)   
+{                              
+  assert(characteristics_are_initialized()); 
+  free(characteristic_map);            
+  characteristic_map = NULL;           
+}
+/***************************************************************************
+ Test the characteristic of a index position on map
+ ***************************************************************************/
+
+bool is_characteristic(int i, characteristic_type mask )
+{
+  return BV_CHECK_MASK(characteristic_map[i], mask);
+}
+
+/******************************************************************
+ Return the number of tiles adjacent to the given place with the right
+ characteristic mask.
+ ******************************************************************/
+int count_characteristic_near(int i, bool cardinal_only, bool percentage
+                             ,characteristic_type mask)
+{
+  int count = 0, total = 0, x, y;
+
+  index_to_map_pos(&x, &y, i);
+  variable_adjc_iterate(x, y, x1, y1, cardinal_only) {
+    if (is_characteristic(map_pos_to_index(x1,y1), mask)) {
+      count++;
+    }
+    total++;
+  } variable_adjc_iterate_end;
+
+  if (percentage) {
+    count = count * 100 / total;
+  }
+  return count;
+}
+/**************************************************************************** 
+  set all tiles in placed_map when this has the right CM_XXX mask
+****************************************************************************/
+static void set_all_mask_placed(characteristic_type mask) 
+{                               
+  whole_map_iterate(x, y) {     
+    if (is_characteristic(map_pos_to_index(x,y),mask)) { 
+      map_set_placed(x, y);     
+    }                           
+  } whole_map_iterate_end;      
+}
+
+/*************************************************************************
+ set CB_OCEANIC in thiles will be oceans
+ ************************************************************************/
+void characteristics_initialize_shores(void)
+{
+  if (HAS_POLES) {
+    normalize_hmap_poles();
+  }
+  hmap_shore_level = (hmap_max_level * (100 - map.landpercent)) / 100;
+  whole_map_iterate_index(i) {
+    if (height_map[i] < hmap_shore_level) {
+      BV_SET(characteristic_map[i], CB_OCEANIC);
+    }
+  } whole_map_iterate_index_end;
+  if (HAS_POLES) {
+    renormalize_hmap_poles();
+  } 
+}
+
+/*************************************************************************
+ if separatepoles is set, return false if this tile has to keep ocean
+************************************************************************/
+static bool ok_for_separate_poles(int index) 
+{
+  int x, y;
+  if (!map.separatepoles) {
+    return TRUE;
+  }
+  index_to_map_pos(&x, &y, index);
+  adjc_iterate(x, y, x1, y1) {
+    if(!is_characteristic(map_pos_to_index(x1, y1), CM_OCEANIC) &&
+       (map_colatitude(x1, y1) > 2 * ICE_BASE_LEVEL)) {
+      return FALSE;
+    }
+  } adjc_iterate_end;
+  return TRUE;
+}
+
+/****************************************************************************
+  Place untextured land at the poles.  This is used by generators 1 and 5
+  on tiles-sets with not forzen oceans
+****************************************************************************/
+void characteristics_initialize_extra_polar_land(void)
+{
+  whole_map_iterate_index(i) {
+    if ((colatitude(i) <=  2 * ICE_BASE_LEVEL) &&
+         ok_for_separate_poles(i)) {
+      BV_CLR(characteristic_map[i], CB_OCEANIC);
+    } 
+  } whole_map_iterate_index_end;
+}
+
+/**************************************************************************
+  we don't want huge flat areas, 
+  so we put in a hill here and there, where it gets too flat 
+
+  Return TRUE if the terrain at the given map position is too flat.  This
+  means that all the terrain for 2 squares around it are only flat.
+****************************************************************************/
+static bool terrain_is_too_flat(int index, int thill, int my_height)
+{
+  int higher_than_me = 0, x, y;
+
+  index_to_map_pos(&x, &y, index);
+  square_iterate(x, y, 2, x1, y1) {
+    if (hmap(x1, y1) > thill) {
+      return FALSE;
+    }
+    if (hmap(x1, y1) > my_height) {
+      if (map_distance(x, y, x1, y1) == 1) {
+       return FALSE;
+      }
+      if (++higher_than_me > 2) {
+       return FALSE;
+      }
+    }
+  } square_iterate_end;
+
+  if ((thill - hmap_shore_level) * higher_than_me  > 
+      (my_height - hmap_shore_level) * 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 heigh 
+
+  Return TRUE if the terrain at the given map position is too heigh.
+****************************************************************************/
+static bool terrain_is_too_high(int index, int thill, int my_height)
+{
+  int x, y;
+
+  index_to_map_pos(&x, &y, index);
+  square_iterate(x, y, 1, x1, y1) {
+    if (hmap(x1, y1) + (hmap_max_level - hmap_mountain_level) / 5 < thill) {
+      return FALSE;
+    }
+  } square_iterate_end;
+  return TRUE;
+}
+
+/**************************************************************************
+  make_relief() will convert all squares that are higher than thill to
+  mountains and hills. Note that thill will be adjusted according to
+  the map.steepness value, so increasing map.steepness will result in
+  more hilly and abrupts maps.
+**************************************************************************/
+void characteristics_initialize_relief(void)
+{
+  /* Calculate the mountain level.  map.mountains specifies the percentage
+   * of land that is turned into hills and mountains. */
+  hmap_mountain_level = ((hmap_max_level - hmap_shore_level)
+                        * (100 - map.steepness)) / 100 + hmap_shore_level;
+
+  whole_map_iterate_index(i) {
+    if (!is_characteristic(i, CM_OCEANIC) &&
+       ((hmap_mountain_level < height_map[i] && 
+         (myrand(10) > 5 
+          || !terrain_is_too_high(i, hmap_mountain_level, height_map[i])))
+        || terrain_is_too_flat(i, hmap_mountain_level, height_map[i]))) {
+      /* Randomly place hills and mountains on "high" tiles. */
+      if (myrand(100) > 70) {
+       BV_SET(characteristic_map[i], CB_ABRUPT);
+      } else {
+       BV_SET(characteristic_map[i], CB_HILLY);
+      }
+    } else {
+       BV_SET(characteristic_map[i], CB_FLAT);
+    }
+  } whole_map_iterate_index_end;
+}
+
+/***************************************************************************
+ * create_tmap initialize the temperature_map
+ * if arg is FALSE, create a dumy tmap == map_colattitude
+ * to be used if hmap or oceans are not placed gen 2-4
+ ***************************************************************************/
+void characteristics_initialize_temperature(bool real)
+{
+  int temperature[MAX_MAP_INDEX];
+
+  whole_map_iterate_index(i) {
+  
+     /* the base temperature is equal to base map_colatitude */
+    int t = colatitude(i) ;
+    if (!real) {
+      temperature[i] =  t;
+    } else {
+      /* height land can be 30% collest */
+      float height = - 0.3 * MAX(0, height_map[i] - hmap_shore_level) 
+         / (hmap_max_level - hmap_shore_level); 
+      /* near ocean temperature can be 15 % more "temperate" */
+      float temperate = 0.15 * (map.temperature / 100 - t / MAX_COLATITUDE) * 
+         2 * MIN (50 ,
+                  count_characteristic_near(i, FALSE, TRUE, CM_OCEANIC)) /
+         100;
+      
+      temperature[i] = t * (1.0 + temperate) * (1.0 + height);
+    }
+  } whole_map_iterate_index_end;
+  /* adjust to get well sizes frequencies */
+  /* Notice: if colatitude is load from a scenario never call adjust has
+             scenario maybe has a odd colatitude ditribution and adjust will
+            brack it */
+  if (!map.alltemperate) {
+    adjust_int_map(temperature, MAX_COLATITUDE);
+  }
+  /* now simplify to 4 base values */ 
+  whole_map_iterate_index(i) {
+    int t = temperature[i];
+
+    /* first if is a hack to avoid some ugly effect,
+       TODO: think if there is a best way, veriffy off by one in colatitude */ 
+    if (colatitude(i) < 2 * ICE_BASE_LEVEL) {
+      BV_SET(characteristic_map[i], CB_FROZEN);
+    } 
+
+    else if (t >= TROPICAL_LEVEL ) {
+      BV_SET(characteristic_map[i], CB_TROPICAL);
+    } else if (t >= COLD_LEVEL) {
+      BV_SET(characteristic_map[i], CB_TEMPERATE);
+    } else if (t >= 2 * ICE_BASE_LEVEL) {
+      BV_SET(characteristic_map[i], CB_COLD);
+    } else {
+      BV_SET(characteristic_map[i], CB_FROZEN);
+    }
+  }  whole_map_iterate_index_end;
+}
+/***************************************************************************
+  Passed as data to rand_map_pos_filtered() by rand_map_pos_characteristic()
+***************************************************************************/
+struct DataFilter {
+    characteristic_type c1, c2, c3;
+};
+
+/****************************************************************************
+  A filter function to be passed to rand_map_pos_filtered().  See
+  rand_map_pos_characteristic for more explanation.
+****************************************************************************/
+static bool condition_filter(int x, int y, void *data)
+{
+  struct DataFilter *filter = data;
+  int index = map_pos_to_index(x, y);
+
+  return  not_placed(index) 
+       && is_characteristic(index, filter->c1) 
+       && is_characteristic(index, filter->c2) 
+       && is_characteristic(index, filter->c3);
+}
+
+/****************************************************************************
+  Return random map coordinates which have some conditions and which are
+  not yet placed on pmap.
+  Returns FALSE if there is no such position.
+****************************************************************************/
+bool rand_index_characteristic(int *index, characteristic_type c1,
+                              characteristic_type c2, characteristic_type c3 )
+{
+  struct DataFilter filter;
+  int x, y;
+
+  filter.c1 = c1;
+  filter.c2 = c2;
+  filter.c3 = c3;
+  if (rand_map_pos_filtered(&x, &y, &filter, condition_filter)) {
+    *index = map_pos_to_index(x, y);
+    return TRUE;
+  } else {
+    return FALSE;
+  } 
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_blocked(int index, int *river_map)
+{
+  if (TEST_BIT(river_map[index], RS_BLOCKED))
+    return 1;
+
+  /* any un-blocked? */
+  index_cardinal_adjc_dir_iterate(index, index1, dir) {
+    if (!TEST_BIT(river_map[index1], RS_BLOCKED))
+      return 0;
+  } index_cardinal_adjc_dir_iterate_end;
+
+  return 1; /* none non-blocked |- all blocked */
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_rivergrid(int index,int *river_map)
+{
+  return (count_characteristic_near(index, TRUE, FALSE, CM_RIVER) 
+         > 1) ? 1 : 0;
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_highlands(int index,int *river_map)
+{
+  return ((is_characteristic(index, CM_HILLY)  ? 1 : 0) +
+         (is_characteristic(index, CM_ABRUPT) ? 2 : 0));
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_adjacent_ocean(int index,int *river_map)
+{
+  return 100 - count_characteristic_near(index, TRUE, TRUE, CM_OCEANIC);
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_adjacent_river(int index,int *river_map)
+{
+  return 100 - count_characteristic_near(index, TRUE, TRUE, CM_RIVER);
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_adjacent_highlands(int index,int *river_map)
+{
+  return (count_characteristic_near(index, TRUE, TRUE, CM_HILLY)
+         + 2 * count_characteristic_near(index, TRUE, TRUE, CM_ABRUPT));
+}
+
+/*********************************************************************
+ Help function used in make_river(). See the help there.
+*********************************************************************/
+static int river_test_height_map(int index,int *river_map)
+{
+  return height_map[index];
+}
+
+/*********************************************************************
+ Called from make_river. Marks all directions as blocked.  -Erik Sigra
+*********************************************************************/
+static void river_blockmark(int index,int *river_map)
+{
+  freelog(LOG_DEBUG, "Blockmarking (%d) and adjacent tiles.",
+         index);
+
+  river_map[index] |= (1u << RS_BLOCKED);
+
+  index_cardinal_adjc_dir_iterate(index, index1, dir) {
+    river_map[index1] |= (1u << RS_BLOCKED);
+  } index_cardinal_adjc_dir_iterate_end;
+}
+
+struct test_func {
+  int (*func)(int, int*);
+  bool fatal;
+};
+
+#define NUM_TEST_FUNCTIONS 7
+static struct test_func test_funcs[NUM_TEST_FUNCTIONS] = {
+  {river_test_blocked,            TRUE},
+  {river_test_rivergrid,          TRUE},
+  {river_test_highlands,          FALSE},
+  {river_test_adjacent_ocean,     FALSE},
+  {river_test_adjacent_river,     FALSE},
+  {river_test_adjacent_highlands, FALSE},
+  {river_test_height_map,         FALSE}
+};
+
+/********************************************************************
+ Makes a river starting at (x, y). Returns 1 if it succeeds.
+ Return 0 if it fails. The river is stored in river_map.
+ 
+ How to make a river path look natural
+ =====================================
+ Rivers always flow down. Thus rivers are best implemented on maps
+ where every tile has an explicit height value. However, Freeciv has a
+ flat map. But there are certain things that help the user imagine
+ differences in height between tiles. The selection of direction for
+ rivers should confirm and even amplify the user's image of the map's
+ topology.
+ 
+ To decide which direction the river takes, the possible directions
+ are tested in a series of test until there is only 1 direction
+ left. Some tests are fatal. This means that they can sort away all
+ remaining directions. If they do so, the river is aborted. Here
+ follows a description of the test series.
+ 
+ * Falling into itself: fatal
+     (river_test_blocked)
+     This is tested by looking up in the river_map array if a tile or
+     every tile surrounding the tile is marked as blocked. A tile is
+     marked as blocked if it belongs to the current river or has been
+     evaluated in a previous iteration in the creation of the current
+     river.
+     
+     Possible values:
+     0: Is not falling into itself.
+     1: Is falling into itself.
+     
+ * Forming a 4-river-grid: optionally fatal
+     (river_test_rivergrid)
+     A minimal 4-river-grid is formed when an intersection in the map
+     grid is surrounded by 4 river tiles. There can be larger river
+     grids consisting of several overlapping minimal 4-river-grids.
+     
+     Possible values:
+     0: Is not forming a 4-river-grid.
+     1: Is forming a 4-river-grid.
+
+ * Highlands:
+     (river_test_highlands)
+     Rivers must not flow up in mountains or hills if there are
+     alternatives.
+     
+     Possible values:
+     0: Is not hills and not mountains.
+     1: Is hills.
+     2: Is mountains.
+
+ * Adjacent ocean:
+     (river_test_adjacent_ocean)
+     Rivers must flow down to coastal areas when possible:
+
+     Possible values: 0-100
+
+ * Adjacent river:
+     (river_test_adjacent_river)
+     Rivers must flow down to areas near other rivers when possible:
+
+     Possible values: 0-100
+                                       
+ * Adjacent highlands:
+     (river_test_adjacent_highlands)
+     Rivers must not flow towards highlands if there are alternatives. 
+     
+ * height_map:
+     (river_test_height_map)
+     Rivers must flow in the direction which takes it to the tile with
+     the lowest value on the height_map.
+     
+     Possible values:
+     n: height_map[...]
+     
+ If these rules haven't decided the direction, the random number
+ generator gets the desicion.                              -Erik Sigra
+*********************************************************************/
+static bool make_river(int index, int *river_map)
+{
+  /* Comparison value for each tile surrounding the current tile.  It is
+   * the suitability to continue a river to the tile in that direction;
+   * lower is better.  However rivers may only run in cardinal directions;
+   * the other directions are ignored entirely. */
+  int rd_comparison_val[8];
+
+  bool rd_direction_is_valid[8];
+  int num_valid_directions, func_num, direction;
+
+  while (TRUE) {
+    /* Mark the current tile as river. */
+    river_map[index] |= (1u << RS_RIVER);
+    freelog(LOG_DEBUG,
+           "The tile at (%d) has been marked as river in river_map.\n",
+           index);
+
+    /* Test if the river is done. */
+    /* We arbitrarily make rivers end at the poles. */
+    if (count_characteristic_near(index, TRUE, TRUE, CM_RIVER)
+       + count_characteristic_near(index, TRUE, TRUE, CM_OCEANIC) > 0
+        || (is_characteristic(index, CM_FROZEN) 
+           &&  is_characteristic(index, CM_FLAT))) { 
+
+      freelog(LOG_DEBUG,
+             "The river ended at (%d).\n", index);
+      return TRUE;
+    }
+
+    /* Else choose a direction to continue the river. */
+    freelog(LOG_DEBUG,
+           "The river did not end at (%d). Evaluating directions...\n",
+           index);
+
+    /* Mark all available cardinal directions as available. */
+    memset(rd_direction_is_valid, 0, sizeof(rd_direction_is_valid));
+    index_cardinal_adjc_dir_iterate(index, index1, dir) {
+      rd_direction_is_valid[dir] = TRUE;
+      if (0 == index1) continue; /* silence warning */
+    } index_cardinal_adjc_dir_iterate_end;
+
+    /* Test series that selects a direction for the river. */
+    for (func_num = 0; func_num < NUM_TEST_FUNCTIONS; func_num++) {
+      int best_val = -1;
+
+      /* first get the tile values for the function */
+      index_cardinal_adjc_dir_iterate(index, index1, dir) {
+
+       if (rd_direction_is_valid[dir]) {
+         rd_comparison_val[dir] = 
+             (test_funcs[func_num].func) (index1 , river_map);
+         if (best_val == -1) {
+           best_val = rd_comparison_val[dir];
+         } else {
+           best_val = MIN(rd_comparison_val[dir], best_val);
+         }
+       }
+      } index_cardinal_adjc_dir_iterate_end;
+      assert(best_val != -1);
+
+      /* should we abort? */
+      if (best_val > 0 && test_funcs[func_num].fatal) {
+       return FALSE;
+      }
+
+      /* mark the less attractive directions as invalid */
+      index_cardinal_adjc_dir_iterate(index, index1, dir) {
+       if (rd_direction_is_valid[dir]) {
+         if (rd_comparison_val[dir] != best_val) {
+           rd_direction_is_valid[dir] = FALSE;
+         }
+       }
+       if (index == index1) continue; /* silence warning */
+      } index_cardinal_adjc_dir_iterate_end;
+    }
+
+    /* Directions evaluated with all functions. Now choose the best
+       direction before going to the next iteration of the while loop */
+    num_valid_directions = 0;
+    index_cardinal_adjc_dir_iterate(index, index1, dir) {
+      if (rd_direction_is_valid[dir]) {
+       num_valid_directions++;
+      }
+      if (index == index1) continue; /* silence warning */
+    } index_cardinal_adjc_dir_iterate_end;
+
+    if (num_valid_directions == 0) {
+      return FALSE; /* river aborted */
+    }
+
+    /* One or more valid directions: choose randomly. */
+    freelog(LOG_DEBUG, "mapgen.c: Had to let the random number"
+           " generator select a direction for a river.");
+    direction = myrand(num_valid_directions);
+    freelog(LOG_DEBUG, "mapgen.c: direction: %d", direction);
+
+    /* Find the direction that the random number generator selected. */
+    index_cardinal_adjc_dir_iterate(index, index1, dir) {
+
+      if (rd_direction_is_valid[dir]) {
+       if (direction > 0) {
+         direction--;
+       } else {
+         river_blockmark(index1, river_map);
+         index = index1;
+         break;
+       }
+      }
+    } index_cardinal_adjc_dir_iterate_end;
+    assert(direction == 0);
+
+  } /* end while; (Make a river.) */
+}
+
+/**************************************************************************
+  Calls make_river until there are enough river tiles on the map. It stops
+  when it has tried to create RIVERS_MAXTRIES rivers.           -Erik Sigra
+**************************************************************************/
+static void make_rivers(int river_pct, int *river_probability)
+{
+  int river_map[MAX_MAP_INDEX], index;
+
+  /* Formula to make the river density similar om different sized maps. Avoids
+     too few rivers on large maps and too many rivers on small maps. */
+  int desirable_riverlength =
+    river_pct *
+      /* The size of the map (poles counted in river_pct). */
+      map_num_tiles() *
+      /* Rivers need to be on land only. */
+      map.landpercent /
+      /* Adjustment value. Tested by me. Gives no rivers with 'set
+        rivers 0', gives a reasonable amount of rivers with default
+        settings and as many rivers as possible with 'set rivers 100'. */
+      5325;
+
+  /* The number of river tiles that have been set. */
+  int current_riverlength = 0;
+
+  /* Counts the number of iterations (should increase with 1 during
+     every iteration of the main loop in this function).
+     Is needed to stop a potentially infinite loop. */
+  int iteration_counter = 0;
+
+  create_placed_map(); /* needed bu rand_map_characteristic */
+  set_all_mask_placed(CM_OCEANIC);
+
+  /* The main loop in this function. */
+  while (current_riverlength < desirable_riverlength
+        && iteration_counter < RIVERS_MAXTRIES) {
+
+    if (!rand_index_characteristic(&index, 
+                                     CM_NFROZEN, CM_TRUE, CM_TRUE)) {
+       break; /* mo more spring places */
+    }
+
+    /* Check if it is suitable to start a river on the current tile.
+     */
+    if ((myrand(100) < river_probability[index])
+       /* Don't start a river on a tile is surrounded by > 1 river +
+          ocean tile. */
+       && (count_characteristic_near(index, TRUE, FALSE, CM_RIVER)
+          + count_characteristic_near(index, TRUE, FALSE, CM_OCEANIC) <= 1)
+
+       /* Don't start a river on a tile that is surrounded by hills or
+          mountains unless it is hard to find somewhere else to start
+          it. */
+       && (count_characteristic_near(index,TRUE, TRUE, CM_ABRUPT)
+         + count_characteristic_near(index, TRUE, TRUE, CM_HILLY) < 90
+           || (iteration_counter > RIVERS_MAXTRIES / 10 * 5))
+
+       /* Don't start a river on hills unless it is hard to find
+          somewhere else to start it. */
+       && (!is_characteristic(index, CM_HILLY)
+           || (iteration_counter > RIVERS_MAXTRIES / 10 * 6))
+
+       /* Don't start a river on mountains unless it is hard to find
+          somewhere else to start it. */
+       && (!is_characteristic(index, CM_ABRUPT)
+           || (iteration_counter > RIVERS_MAXTRIES / 10 * 7))
+       ) {
+
+      /* Reset river_map before making a new river. */
+      whole_map_iterate_index(i) {
+       river_map[i] = 0;
+      } whole_map_iterate_index_end;
+
+      freelog(LOG_DEBUG,
+             "Found a suitable starting tile for a river at (%d)."
+             " Starting to make it.",
+             index);
+
+      /* Try to make a river. If it is OK, apply it to the map. */
+      if (make_river(index, river_map)) {
+       whole_map_iterate(x1, y1) {
+         if (TEST_BIT(river_map[map_pos_to_index(x1, y1)], RS_RIVER)) {
+           BV_SET(characteristic_map[map_pos_to_index(x1, y1)], CB_RIVER);
+           current_riverlength++;
+           map_set_placed(x1, y1);
+           /* reduce probability near a river */
+           circle_iterate(x1, y1, 4, x2, y2) {
+               river_probability[map_pos_to_index(x2, y2)] *= 0.9;
+           } circle_iterate_end;
+           freelog(LOG_DEBUG, "Applied a river to (%d).",
+                   map_pos_to_index(x1, y1));
+         }
+       } whole_map_iterate_end;
+      }
+      else {
+       freelog(LOG_DEBUG,
+       "mapgen.c: A river failed. It might have gotten stuck in a helix.");
+      }
+    } /* end if; */
+    iteration_counter++;
+    freelog(LOG_DEBUG,
+    "current_riverlength: %d; desirable_riverlength: %d; iteration_counter: 
%d",
+           current_riverlength, desirable_riverlength, iteration_counter);
+  } /* end while; */
+
+  destroy_placed_map();
+}
+
+/**************************************************************************
+  Change the values of the integer map, so that they contain ranking of each 
+  tile scaled to [0 .. int_map_max]. on tiles with the right characteristics
+**************************************************************************/
+static void adjust_int_map_masks(int *int_map, int int_map_max,
+                         characteristic_type mask,characteristic_type Nmask )
+{
+  int minval = 1000000000, maxval = -1000000000, total = 0;
+
+  /* Determine minimum and maximum value. */
+  whole_map_iterate_masks_index(j, mask, Nmask) {
+    maxval = MAX(maxval, int_map[j]);
+    minval = MIN(minval, int_map[j]);
+    total++;
+  } whole_map_iterate_masks_index_end;
+
+  {
+    int const size = 1 + maxval - minval;
+    int i, count = 0, frequencies[size];
+
+    INITIALIZE_ARRAY(frequencies, size, 0);
+
+    /* Translate value so the minimum value is 0
+       and count the number of occurencies of all values to initialize the 
+       frequencies[] */
+    whole_map_iterate_masks_index(j, mask, Nmask) {
+      int_map[j] = (int_map[j] - minval);
+      frequencies[int_map[j]]++;
+    } whole_map_iterate_masks_index_end ;
+
+    /* create the linearize function as "incremental" frequencies */
+    for(i =  0; i < size; i++) {
+      count += frequencies[i]; 
+      frequencies[i] = (count * int_map_max) / total;
+    }
+
+    /* apply the linearize function */
+    whole_map_iterate_masks_index(j, mask, Nmask) {
+      int_map[j] = frequencies[int_map[j]];
+    } whole_map_iterate_masks_index_end;
+  }
+}
+
+
+#define colatitude_is_dry(i)                           \
+  (colatitude((i)) <= DRY_MAX_LEVEL                    \
+   && colatitude((i)) > DRY_MIN_LEVEL)
+
+void characteristics_initialize_wetness(int river_pct)
+{
+  int wetness[MAX_MAP_INDEX];
+  /* there wetness[]  means the probability to start a river*/
+  whole_map_iterate_index(i) {
+    if (colatitude_is_dry(i)) {
+      wetness[i] = 70;
+    } else {
+      wetness[i] = 100;
+    }
+  } whole_map_iterate_index_end;
+
+  make_rivers(river_pct, wetness);
+
+  /* now wetness[] means amount of water */
+  whole_map_iterate_index(i) {
+    float dry_bonus = colatitude_is_dry(i) ? 1 : 0;
+    float tropical_bonus = (colatitude(i) > TROPICAL_LEVEL) ? 1 : 0;
+    float height_bonus = MAX(0, (height_map[i] -  hmap_shore_level))
+                            / (hmap_max_level - hmap_shore_level);
+    float river_bonus = is_characteristic(i, CM_RIVER) ? 1 : 0;
+    float ocean_bonus = is_characteristic(i, CM_OCEANIC) ? 1 : 0;
+
+    wetness[i] = (100 - 10 * dry_bonus + 5 * tropical_bonus)
+       * (100 + 30 * river_bonus + 20 * ocean_bonus)
+       * (100 + 30 * height_bonus) / 100;
+  } whole_map_iterate_index_end;
+
+  smooth_int_map(wetness, FALSE);
+  adjust_int_map_masks(wetness, 1000, CM_FLAT, CM_OCEANIC);
+  adjust_int_map_masks(wetness, 1000, CM_HILLY, CM_OCEANIC);
+  adjust_int_map_masks(wetness, 1000, CM_ABRUPT, CM_OCEANIC);
+
+  whole_map_iterate_index(i) {
+    if (is_characteristic(i, CM_OCEANIC)) {
+      continue;
+    }
+    if (wetness[i] < 300) {
+      BV_SET(characteristic_map[i], CB_DRY);
+    } else if(wetness[i] < 700){
+      BV_SET(characteristic_map[i], CB_MEDIUM);
+    } else  {
+      BV_SET(characteristic_map[i], CB_WET);
+    } 
+  } whole_map_iterate_index_end;
+}
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/characteristics.h 
freeciv_/server/generator/characteristics.h
--- freeciv/server/generator/characteristics.h  1970-01-01 01:00:00.000000000 
+0100
+++ freeciv_/server/generator/characteristics.h 2004-09-22 17:12:04.000000000 
+0200
@@ -0,0 +1,84 @@
+/********************************************************************** 
+   Copyright (C) 1996-2004 - The Freeciv Project Team,
+   This program is free software; you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 2, or (at your option)
+   any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+***********************************************************************/
+#ifndef FC__CHARACTERISTICS_H
+#define FC__CHARACTERISTICS_H
+
+BV_DEFINE(characteristic_type, 13);
+typedef enum  {CB_TRUE = 0, 
+              CB_RIVER,
+              CB_FROZEN , CB_COLD , CB_TEMPERATE, CB_TROPICAL,
+               CB_OCEANIC,  CB_WET , CB_MEDIUM , CB_DRY ,
+               CB_FLAT, CB_HILLY, CB_ABRUPT} characteristic_bits;
+
+/* test for CM_TRUE mask is all the time TRUE, 
+ * test for CM_FALSE mask is FALSE! 
+ */
+extern characteristic_type CM_TRUE, CM_FALSE;
+extern characteristic_type CM_FLAT, CM_HILLY, CM_ABRUPT,
+                           CM_NFLAT;
+extern characteristic_type CM_FROZEN, CM_COLD, CM_TEMPERATE, CM_TROPICAL,
+                           CM_NFROZEN,  CM_ALL, CM_NHOT, CM_HOT;
+/*
+ CM_NFROZEN == (CM_COLD | CM_TEMPERATE | CM_TROPICAL)
+ CM_ALL     == (CM_FROZEN | CM_NFROZEN)
+ CM_NHOT    == (CM_FROZEN | CM_COLD)
+ CM_HOT     == (CM_TEMPERATE, CM_TROPICAL)
+ */
+                          
+extern characteristic_type CM_OCEANIC,  CM_WET, CM_MEDIUM, CM_DRY,
+                           CM_NWET, CM_NDRY;
+extern characteristic_type CM_RIVER;
+
+bool characteristics_are_initialized(void);
+void create_characteristics(void);
+void destroy_characteristics(void);  
+
+bool is_characteristic(int index, characteristic_type mask );
+int count_characteristic_near(int index , bool cardinal_only, bool percentage,
+                             characteristic_type mask);
+
+bool rand_index_characteristic(int *index, characteristic_type c1,
+                              characteristic_type c2,characteristic_type c3 );
+
+void characteristics_initialize_shores(void);
+void characteristics_initialize_extra_polar_land(void);
+void characteristics_initialize_relief(void);
+void characteristics_initialize_temperature(bool real);
+void characteristics_initialize_wetness(int river_pct);
+
+/*
+ * little iterator on indexes
+ */
+#define index_cardinal_adjc_dir_iterate(index, index1, dir) \
+  { \
+    int _x, _y; \
+    index_to_map_pos(&_x, &_y, (index)); \
+    cardinal_adjc_dir_iterate(_x, _y, _x1, _y1, dir) { \
+      const int index1 = map_pos_to_index(_x1, _y1);
+ 
+#define index_cardinal_adjc_dir_iterate_end \
+        } cardinal_adjc_dir_iterate_end; }
+
+/*
+ iterate on tile with the right mask and with not the Nmask
+*/
+
+#define  whole_map_iterate_masks_index(i, mask, Nmask) \
+   whole_map_iterate_index(i) { \
+   if(is_characteristic(i, Nmask) || !is_characteristic(i, mask)) { \
+     continue; \
+   }
+
+#define  whole_map_iterate_masks_index_end } whole_map_iterate_index_end
+
+#endif  /* FC__CHARACTERISTICS_H */
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/Makefile.am 
freeciv_/server/generator/Makefile.am
--- freeciv/server/generator/Makefile.am        2004-09-16 11:53:11.000000000 
+0200
+++ freeciv_/server/generator/Makefile.am       2004-09-22 17:12:04.000000000 
+0200
@@ -14,5 +14,5 @@
        height_map.h \
        startpos.c \
        startpos.h \
-       temperature_map.c \
-       temperature_map.h
+       characteristics.h \
+       characteristics.c
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/mapgen.c 
freeciv_/server/generator/mapgen.c
--- freeciv/server/generator/mapgen.c   2004-09-22 08:39:29.000000000 +0200
+++ freeciv_/server/generator/mapgen.c  2004-09-22 17:12:04.000000000 +0200
@@ -36,9 +36,8 @@
 #include "height_map.h"
 #include "mapgen_topology.h"
 #include "startpos.h"
-#include "temperature_map.h"
 #include "utilities.h"
-
+#include "characteristics.h"
 
 /* Old-style terrain enumeration: deprecated. */
 enum {
@@ -56,17 +55,6 @@
 static void mapgenerator4(void);
 static void adjust_terrain_param(void);
 
-#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.
-   A value of 2 means river.                            -Erik Sigra */
-static int *river_map;
-
-#define HAS_POLES (map.temperature < 70 && !map.alltemperate  )
-
 /* These are the old parameters of terrains types in %
    TODO: they depend on the hardcoded terrains */
 static int forest_pct = 0;
@@ -76,272 +64,45 @@
 static int jungle_pct = 0;
 static int river_pct = 0;
  
-/****************************************************************************
- * Conditions used mainly in rand_map_pos_characteristic()
- ****************************************************************************/
-/* WETNESS */
-
-/* necessary condition of deserts placement */
-#define map_pos_is_dry(x, y)                                           \
-  (map_colatitude((x), (y)) <= DRY_MAX_LEVEL                           \
-   && map_colatitude((x), (y)) > DRY_MIN_LEVEL                         \
-   && count_ocean_near_tile((x), (y), FALSE, TRUE) <= 35)
-typedef enum { WC_ALL = 200, WC_DRY, WC_NDRY } wetness_c;
-
-/* MISCELANEOUS (OTHER CONDITIONS) */
-
-/* necessary condition of swamp placement */
-static int hmap_low_level = 0;
-#define ini_hmap_low_level() \
-{ \
-hmap_low_level = (4 * swamp_pct  * \
-     (hmap_max_level - hmap_shore_level)) / 100 + hmap_shore_level; \
-}
-/* should be used after having hmap_low_level initialized */
-#define map_pos_is_low(x, y) ((hmap((x), (y)) < hmap_low_level))
-
-typedef enum { MC_NONE, MC_LOW, MC_NLOW } miscellaneous_c;
-
-/***************************************************************************
- These functions test for conditions used in rand_map_pos_characteristic 
-***************************************************************************/
-
-/***************************************************************************
-  Checks if the given location satisfy some wetness condition
-***************************************************************************/
-static bool test_wetness(int x, int y, wetness_c c)
-{
-  switch(c) {
-  case WC_ALL:
-    return TRUE;
-  case WC_DRY:
-    return map_pos_is_dry(x, y);
-  case WC_NDRY:
-    return !map_pos_is_dry(x, y);
-  }
-  assert(0);
-  return FALSE;
-}
-
-/***************************************************************************
-  Checks if the given location satisfy some miscellaneous condition
-***************************************************************************/
-static bool test_miscellaneous(int x, int y, miscellaneous_c c)
-{
-  switch(c) {
-  case MC_NONE:
-    return TRUE;
-  case MC_LOW:
-    return map_pos_is_low(x, y);
-  case MC_NLOW:
-    return !map_pos_is_low(x, y);
-  }
-  assert(0);
-  return FALSE;
-}
-
-/***************************************************************************
-  Passed as data to rand_map_pos_filtered() by rand_map_pos_characteristic()
-***************************************************************************/
-struct DataFilter {
-  wetness_c wc;
-  temperature_type tc;
-  miscellaneous_c mc;
-};
-
-/****************************************************************************
-  A filter function to be passed to rand_map_pos_filtered().  See
-  rand_map_pos_characteristic for more explanation.
-****************************************************************************/
-static bool condition_filter(int map_x, int map_y, void *data)
-{
-  struct DataFilter *filter = data;
-
-  return  not_placed(map_x, map_y) 
-       && tmap_is(map_x, map_y, filter->tc) 
-       && test_wetness(map_x, map_y, filter->wc) 
-       && test_miscellaneous(map_x, map_y, filter->mc) ;
-}
-
-/****************************************************************************
-  Return random map coordinates which have some conditions and which are
-  not yet placed on pmap.
-  Returns FALSE if there is no such position.
-****************************************************************************/
-static bool rand_map_pos_characteristic(int *map_x, int *map_y,
-                                       wetness_c wc,
-                                       temperature_type tc,
-                                       miscellaneous_c mc )
-{
-  struct DataFilter filter;
-
-  filter.wc = wc;
-  filter.tc = tc;
-  filter.mc = mc;
-  return rand_map_pos_filtered(map_x, map_y, &filter, condition_filter);
-}
-
-/**************************************************************************
-  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_too_flat(int map_x, int map_y,int thill, int my_height)
-{
-  int higher_than_me = 0;
-  square_iterate(map_x, map_y, 2, x1, y1) {
-    if (hmap(x1, y1) > thill) {
-      return FALSE;
-    }
-    if (hmap(x1, y1) > my_height) {
-      if (map_distance(map_x, map_y, x1, y1) == 1) {
-       return FALSE;
-      }
-      if (++higher_than_me > 2) {
-       return FALSE;
-      }
-    }
-  } square_iterate_end;
-
-  if ((thill - hmap_shore_level) * higher_than_me  > 
-      (my_height - hmap_shore_level) * 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 'heigh' 
-
-  Return TRUE if the terrain at the given map position is too heigh.
-****************************************************************************/
-static bool terrain_is_too_high(int map_x, int map_y,int thill, int my_height)
-{
-  square_iterate(map_x, map_y, 1, x1, y1) {
-    if (hmap(x1, y1) + (hmap_max_level - hmap_mountain_level) / 5 < thill) {
-      return FALSE;
-    }
-  } square_iterate_end;
-  return TRUE;
-}
-
-/**************************************************************************
-  make_relief() will convert all squares that are higher than thill to
-  mountains and hills. Note that thill will be adjusted according to
-  the map.steepness value, so increasing map.mountains will result in
-  more hills and mountains.
+  Recursively generate terrains.
 **************************************************************************/
-static void make_relief(void)
+static void place_terrain(int index, int diff, 
+                         Terrain_type_id ter, int *to_be_placed,
+                         characteristic_type wcm,
+                         characteristic_type tcm,
+                         characteristic_type mcm)
 {
-  /* Calculate the mountain level.  map.mountains specifies the percentage
-   * of land that is turned into hills and mountains. */
-  hmap_mountain_level = ((hmap_max_level - hmap_shore_level)
-                        * (100 - map.steepness)) / 100 + hmap_shore_level;
 
-  whole_map_iterate(x, y) {
-    if (not_placed(x,y) &&
-       ((hmap_mountain_level < hmap(x, y) && 
-         (myrand(10) > 5 
-          || !terrain_is_too_high(x, y, hmap_mountain_level, hmap(x, y))))
-        || terrain_is_too_flat(x, y, hmap_mountain_level, 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) > 70 || tmap_is(x, y, TT_NHOT)) {
-       map_set_terrain(x, y, T_MOUNTAINS);
-       map_set_placed(x, y);
-      } else {
-       map_set_terrain(x, y, T_HILLS);
-       map_set_placed(x, y);
-      }
-    }
-  } whole_map_iterate_end;
-}
+  int x, y;
 
-/****************************************************************************
-  Add arctic and tundra squares in the arctic zone (that is, the coolest
-  10% of the map).  We also texture the pole (adding arctic, tundra, and
-  mountains).  This is used in generators 2-4.
-****************************************************************************/
-static void make_polar(void)
-{
-  whole_map_iterate(map_x, map_y) {  
-    if (tmap_is(map_x, map_y, TT_FROZEN )
-       ||
-       (tmap_is(map_x, map_y, TT_COLD ) &&
-        (myrand(10) > 7) &&
-        is_temperature_type_near(map_x, map_y, TT_FROZEN))) { 
-      map_set_terrain(map_x, map_y, T_ARCTIC);
-    }
-  } whole_map_iterate_end;
-}
-
-/*************************************************************************
- if separatepoles is set, return false if this tile has to keep 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.
-****************************************************************************/
-static void make_polar_land(void)
-{
-  assign_continent_numbers();
-  whole_map_iterate(map_x, map_y) {
-    if ((tmap_is(map_x, map_y, TT_FROZEN ) &&
-       ok_for_separate_poles(map_x, map_y))
-       ||
-       (tmap_is(map_x, map_y, TT_COLD ) &&
-        (myrand(10) > 7) &&
-        is_temperature_type_near(map_x, map_y, TT_FROZEN) &&
-        ok_for_separate_poles(map_x, map_y))) {
-       map_set_terrain(map_x, map_y, T_UNKNOWN);
-       map_set_continent(map_x, map_y, 0);
-    } 
-  } whole_map_iterate_end;
-}
-
-/**************************************************************************
-  Recursively generate terrains.
-**************************************************************************/
-static void place_terrain(int x, int y, int diff, 
-                           Terrain_type_id ter, int *to_be_placed,
-                          wetness_c        wc,
-                          temperature_type tc,
-                          miscellaneous_c  mc)
-{
+  index_to_map_pos(&x, &y, index);
   if (*to_be_placed <= 0) {
     return;
   }
-  assert(not_placed(x, y));
+  assert(map_not_placed(x, y));
   map_set_terrain(x, y, ter);
+  if (is_characteristic(index, CM_RIVER)) {
+    map_set_special(x, y, S_RIVER);
+  }
   map_set_placed(x, y);
   (*to_be_placed)--;
   
   cardinal_adjc_iterate(x, y, x1, y1) {
-    int Delta = abs(map_colatitude(x1, y1) - map_colatitude(x, y)) / L_UNIT
-       + abs(hmap(x1, y1) - (hmap(x, y))) /  H_UNIT;
-    if (not_placed(x1, y1) 
-       && tmap_is(x1, y1, tc) 
-       && test_wetness(x1, y1, wc)
-       && test_miscellaneous(x1, y1, mc)
+    int index1 = map_pos_to_index(x1, y1); 
+    int Delta = abs(colatitude(index1) - colatitude(index)) / L_UNIT
+       + abs(height_map[index1] - (height_map[index])) /  H_UNIT;
+    if (not_placed(index1) 
+       && is_characteristic(index1, tcm) 
+       && is_characteristic(index1, wcm)
+       && is_characteristic(index1, mcm)
+       && (is_characteristic(index1, CM_RIVER) 
+           ? terrain_has_flag(ter, TER_CAN_HAVE_RIVER) : TRUE)
        && Delta < diff 
        && myrand(10) > 4) {
-       place_terrain(x1, y1, diff - 1 - Delta, ter, to_be_placed, wc, tc, mc);
+       place_terrain(index1, diff - 1 - Delta, ter,
+                     to_be_placed, wcm, tcm, mcm);
     }
   } cardinal_adjc_iterate_end;
 }
@@ -350,12 +111,15 @@
   a simple function that adds plains grassland or tundra to the 
   current location.
 **************************************************************************/
-static void make_plain(int x, int y, int *to_be_placed )
+static void make_plain(int index, int *to_be_placed )
 {
+  int x, y;
+
+  index_to_map_pos(&x, &y, index);
   /* in cold place we get tundra instead */
-  if (tmap_is(x, y, TT_FROZEN)) {
+  if (is_characteristic(index, CM_FROZEN)) {
     map_set_terrain(x, y, T_ARCTIC); 
-  } else if (tmap_is(x, y, TT_COLD)) {
+  } else if (is_characteristic(index, CM_COLD)) {
     map_set_terrain(x, y, T_TUNDRA); 
   } else {
     if (myrand(100) > 50) {
@@ -364,6 +128,9 @@
       map_set_terrain(x, y, T_PLAINS);
     }
   }
+  if (is_characteristic(index, CM_RIVER)) {
+      map_set_special(x, y, S_RIVER);
+  }
   map_set_placed(x, y);
   (*to_be_placed)--;
 }
@@ -375,22 +142,23 @@
 static void make_plains(void)
 {
   int to_be_placed;
-  whole_map_iterate(x, y) {
-    if (not_placed(x, y)) {
+  whole_map_iterate_index(i) {
+    if (not_placed(i)) {
       to_be_placed = 1;
-      make_plain(x, y, &to_be_placed);
+      make_plain(i, &to_be_placed);
     }
-  } whole_map_iterate_end;
+  } whole_map_iterate_index_end;
 }
+
 /**************************************************************************
  This place randomly a cluster of terrains with some characteristics
  **************************************************************************/
 #define PLACE_ONE_TYPE(count, alternate, ter, wc, tc, mc, weight) \
   if((count) > 0) {                                       \
-    int x, y; \
+    int index; \
     /* Place some terrains */                             \
-    if (rand_map_pos_characteristic(&x, &y, (wc), (tc), (mc))) {  \
-      place_terrain(x, y, (weight), (ter), &(count), (wc),(tc), (mc));   \
+    if (rand_index_characteristic(&index, (wc), (tc), (mc))) {  \
+      place_terrain(index, (weight), (ter), &(count), (wc),(tc), (mc));   \
     } else {                                                             \
       /* If rand_map_pos_temperature returns FALSE we may as well stop*/ \
       /* looking for this time and go to alternate type. */              \
@@ -416,12 +184,33 @@
   int plains_count = 0;
   int swamps_count = 0;
 
+  create_placed_map();
+
   whole_map_iterate(x, y) {
-    if (not_placed(x,y)) {
-     total++;
+    int index = map_pos_to_index(x, y);
+
+    if (is_characteristic(index, CM_OCEANIC)) {
+      map_set_placed(x, y);
+      map_set_terrain(x, y, T_OCEAN);
+    } else if (is_characteristic(index, CM_HILLY)) {
+      map_set_placed(x, y);
+      map_set_terrain(x, y, T_HILLS);
+      /* hack for terrains-set, where hills are too green */
+      if (is_characteristic(index, CM_FROZEN)) {
+       map_set_terrain(x, y, T_MOUNTAINS);
+      }
+    } else  if (is_characteristic(index, CM_ABRUPT)) {
+      map_set_placed(x, y);
+      map_set_terrain(x, y, T_MOUNTAINS);
     }
   } whole_map_iterate_end;
 
+  whole_map_iterate_index(i) {
+    if (not_placed(i)) {
+     total++;
+    }
+  } whole_map_iterate_index_end;
+
   forests_count = total * forest_pct / (100 - mountain_pct);
   jungles_count = total * jungle_pct / (100 - mountain_pct);
  
@@ -436,23 +225,23 @@
   do {
     
     PLACE_ONE_TYPE(forests_count , plains_count, T_FOREST,
-                  WC_ALL, TT_NFROZEN, MC_NONE, 60);
+                  CM_ALL, CM_NFROZEN, CM_FLAT, 60);
     PLACE_ONE_TYPE(jungles_count, forests_count , T_JUNGLE,
-                  WC_ALL, TT_TROPICAL, MC_NONE, 50);
+                  CM_ALL, CM_TROPICAL, CM_FLAT, 50);
     PLACE_ONE_TYPE(swamps_count, forests_count , T_SWAMP,
-                  WC_NDRY, TT_HOT, MC_LOW, 50);
+                  CM_WET, CM_HOT, CM_FLAT, 30);
     PLACE_ONE_TYPE(deserts_count, alt_deserts_count , T_DESERT,
-                  WC_DRY, TT_NFROZEN, MC_NLOW, 80);
+                  CM_DRY, CM_HOT, CM_FLAT, 80);
     PLACE_ONE_TYPE(alt_deserts_count, plains_count , T_DESERT,
-                  WC_ALL, TT_NFROZEN, MC_NLOW, 40);
+                  CM_NWET, CM_NFROZEN, CM_FLAT, 40);
  
   /* make the plains and tundras */
     if (plains_count > 0) {
-      int x, y;
+      int index;
 
       /* Don't use any restriction here ! */
-      if (rand_map_pos_characteristic(&x, &y,  WC_ALL, TT_ALL, MC_NONE)){
-       make_plain(x,y, &plains_count);
+      if (rand_index_characteristic(&index,  CM_ALL, CM_ALL, CM_ALL)){
+       make_plain(index, &plains_count);
       } else {
        /* If rand_map_pos_temperature returns FALSE we may as well stop
         * looking for plains. */
@@ -462,491 +251,8 @@
   } while (forests_count > 0 || jungles_count > 0 
           || deserts_count > 0 || alt_deserts_count > 0 
           || plains_count > 0 || swamps_count > 0 );
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_blocked(int x, int y)
-{
-  if (TEST_BIT(rmap(x, y), RS_BLOCKED))
-    return 1;
-
-  /* any un-blocked? */
-  cardinal_adjc_iterate(x, y, x1, y1) {
-    if (!TEST_BIT(rmap(x1, y1), RS_BLOCKED))
-      return 0;
-  } cardinal_adjc_iterate_end;
-
-  return 1; /* none non-blocked |- all blocked */
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_rivergrid(int x, int y)
-{
-  return (count_special_near_tile(x, y, TRUE, FALSE, S_RIVER) > 1) ? 1 : 0;
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_highlands(int x, int y)
-{
-  return (((map_get_terrain(x, y) == T_HILLS) ? 1 : 0) +
-         ((map_get_terrain(x, y) == T_MOUNTAINS) ? 2 : 0));
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_adjacent_ocean(int x, int y)
-{
-  return 100 - count_ocean_near_tile(x, y, TRUE, TRUE);
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_adjacent_river(int x, int y)
-{
-  return 100 - count_special_near_tile(x, y, TRUE, TRUE, S_RIVER);
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_adjacent_highlands(int x, int y)
-{
-  return (count_terrain_near_tile(x, y, TRUE, TRUE, T_HILLS)
-         + 2 * count_terrain_near_tile(x, y, TRUE, TRUE, T_MOUNTAINS));
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_swamp(int x, int y)
-{
-  return (map_get_terrain(x, y) != T_SWAMP) ? 1 : 0;
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_adjacent_swamp(int x, int y)
-{
-  return 100 - count_terrain_near_tile(x, y, TRUE, TRUE, T_SWAMP);
-}
-
-/*********************************************************************
- Help function used in make_river(). See the help there.
-*********************************************************************/
-static int river_test_height_map(int x, int y)
-{
-  return hmap(x, y);
-}
 
-/*********************************************************************
- Called from make_river. Marks all directions as blocked.  -Erik Sigra
-*********************************************************************/
-static void river_blockmark(int x, int y)
-{
-  freelog(LOG_DEBUG, "Blockmarking (%d, %d) and adjacent tiles.",
-         x, y);
-
-  rmap(x, y) |= (1u << RS_BLOCKED);
-
-  cardinal_adjc_iterate(x, y, x1, y1) {
-    rmap(x1, y1) |= (1u << RS_BLOCKED);
-  } cardinal_adjc_iterate_end;
-}
-
-struct test_func {
-  int (*func)(int, int);
-  bool fatal;
-};
-
-#define NUM_TEST_FUNCTIONS 9
-static struct test_func test_funcs[NUM_TEST_FUNCTIONS] = {
-  {river_test_blocked,            TRUE},
-  {river_test_rivergrid,          TRUE},
-  {river_test_highlands,          FALSE},
-  {river_test_adjacent_ocean,     FALSE},
-  {river_test_adjacent_river,     FALSE},
-  {river_test_adjacent_highlands, FALSE},
-  {river_test_swamp,              FALSE},
-  {river_test_adjacent_swamp,     FALSE},
-  {river_test_height_map,         FALSE}
-};
-
-/********************************************************************
- Makes a river starting at (x, y). Returns 1 if it succeeds.
- Return 0 if it fails. The river is stored in river_map.
- 
- How to make a river path look natural
- =====================================
- Rivers always flow down. Thus rivers are best implemented on maps
- where every tile has an explicit height value. However, Freeciv has a
- flat map. But there are certain things that help the user imagine
- differences in height between tiles. The selection of direction for
- rivers should confirm and even amplify the user's image of the map's
- topology.
- 
- To decide which direction the river takes, the possible directions
- are tested in a series of test until there is only 1 direction
- left. Some tests are fatal. This means that they can sort away all
- remaining directions. If they do so, the river is aborted. Here
- follows a description of the test series.
- 
- * Falling into itself: fatal
-     (river_test_blocked)
-     This is tested by looking up in the river_map array if a tile or
-     every tile surrounding the tile is marked as blocked. A tile is
-     marked as blocked if it belongs to the current river or has been
-     evaluated in a previous iteration in the creation of the current
-     river.
-     
-     Possible values:
-     0: Is not falling into itself.
-     1: Is falling into itself.
-     
- * Forming a 4-river-grid: optionally fatal
-     (river_test_rivergrid)
-     A minimal 4-river-grid is formed when an intersection in the map
-     grid is surrounded by 4 river tiles. There can be larger river
-     grids consisting of several overlapping minimal 4-river-grids.
-     
-     Possible values:
-     0: Is not forming a 4-river-grid.
-     1: Is forming a 4-river-grid.
-
- * Highlands:
-     (river_test_highlands)
-     Rivers must not flow up in mountains or hills if there are
-     alternatives.
-     
-     Possible values:
-     0: Is not hills and not mountains.
-     1: Is hills.
-     2: Is mountains.
-
- * Adjacent ocean:
-     (river_test_adjacent_ocean)
-     Rivers must flow down to coastal areas when possible:
-
-     Possible values: 0-100
-
- * Adjacent river:
-     (river_test_adjacent_river)
-     Rivers must flow down to areas near other rivers when possible:
-
-     Possible values: 0-100
-                                       
- * Adjacent highlands:
-     (river_test_adjacent_highlands)
-     Rivers must not flow towards highlands if there are alternatives. 
-     
- * Swamps:
-     (river_test_swamp)
-     Rivers must flow down in swamps when possible.
-     
-     Possible values:
-     0: Is swamps.
-     1: Is not swamps.
-     
- * Adjacent swamps:
-     (river_test_adjacent_swamp)
-     Rivers must flow towards swamps when possible.
-
- * height_map:
-     (river_test_height_map)
-     Rivers must flow in the direction which takes it to the tile with
-     the lowest value on the height_map.
-     
-     Possible values:
-     n: height_map[...]
-     
- If these rules haven't decided the direction, the random number
- generator gets the desicion.                              -Erik Sigra
-*********************************************************************/
-static bool make_river(int x, int y)
-{
-  /* Comparison value for each tile surrounding the current tile.  It is
-   * the suitability to continue a river to the tile in that direction;
-   * lower is better.  However rivers may only run in cardinal directions;
-   * the other directions are ignored entirely. */
-  int rd_comparison_val[8];
-
-  bool rd_direction_is_valid[8];
-  int num_valid_directions, func_num, direction;
-
-  while (TRUE) {
-    /* Mark the current tile as river. */
-    rmap(x, y) |= (1u << RS_RIVER);
-    freelog(LOG_DEBUG,
-           "The tile at (%d, %d) has been marked as river in river_map.\n",
-           x, y);
-
-    /* Test if the river is done. */
-    /* We arbitrarily make rivers end at the poles. */
-    if (count_special_near_tile(x, y, TRUE, TRUE, S_RIVER) > 0
-       || count_ocean_near_tile(x, y, TRUE, TRUE) > 0
-        || (map_get_terrain(x, y) == T_ARCTIC 
-           && map_colatitude(x, y) < 0.8 * COLD_LEVEL)) { 
-
-      freelog(LOG_DEBUG,
-             "The river ended at (%d, %d).\n", x, y);
-      return TRUE;
-    }
-
-    /* Else choose a direction to continue the river. */
-    freelog(LOG_DEBUG,
-           "The river did not end at (%d, %d). Evaluating directions...\n",
-           x, y);
-
-    /* Mark all available cardinal directions as available. */
-    memset(rd_direction_is_valid, 0, sizeof(rd_direction_is_valid));
-    cardinal_adjc_dir_iterate(x, y, x1, y1, dir) {
-      rd_direction_is_valid[dir] = TRUE;
-    } cardinal_adjc_dir_iterate_end;
-
-    /* Test series that selects a direction for the river. */
-    for (func_num = 0; func_num < NUM_TEST_FUNCTIONS; func_num++) {
-      int best_val = -1;
-
-      /* first get the tile values for the function */
-      cardinal_adjc_dir_iterate(x, y, x1, y1, dir) {
-       if (rd_direction_is_valid[dir]) {
-         rd_comparison_val[dir] = (test_funcs[func_num].func) (x1, y1);
-         if (best_val == -1) {
-           best_val = rd_comparison_val[dir];
-         } else {
-           best_val = MIN(rd_comparison_val[dir], best_val);
-         }
-       }
-      } cardinal_adjc_dir_iterate_end;
-      assert(best_val != -1);
-
-      /* should we abort? */
-      if (best_val > 0 && test_funcs[func_num].fatal) {
-       return FALSE;
-      }
-
-      /* mark the less attractive directions as invalid */
-      cardinal_adjc_dir_iterate(x, y, x1, y1, dir) {
-       if (rd_direction_is_valid[dir]) {
-         if (rd_comparison_val[dir] != best_val) {
-           rd_direction_is_valid[dir] = FALSE;
-         }
-       }
-      } cardinal_adjc_dir_iterate_end;
-    }
-
-    /* Directions evaluated with all functions. Now choose the best
-       direction before going to the next iteration of the while loop */
-    num_valid_directions = 0;
-    cardinal_adjc_dir_iterate(x, y, x1, y1, dir) {
-      if (rd_direction_is_valid[dir]) {
-       num_valid_directions++;
-      }
-    } cardinal_adjc_dir_iterate_end;
-
-    if (num_valid_directions == 0) {
-      return FALSE; /* river aborted */
-    }
-
-    /* One or more valid directions: choose randomly. */
-    freelog(LOG_DEBUG, "mapgen.c: Had to let the random number"
-           " generator select a direction for a river.");
-    direction = myrand(num_valid_directions);
-    freelog(LOG_DEBUG, "mapgen.c: direction: %d", direction);
-
-    /* Find the direction that the random number generator selected. */
-    cardinal_adjc_dir_iterate(x, y, x1, y1, dir) {
-      if (rd_direction_is_valid[dir]) {
-       if (direction > 0) {
-         direction--;
-       } else {
-         river_blockmark(x, y);
-         x = x1;
-         y = y1;
-         break;
-       }
-      }
-    } cardinal_adjc_dir_iterate_end;
-    assert(direction == 0);
-
-  } /* end while; (Make a river.) */
-}
-
-/**************************************************************************
-  Calls make_river until there are enough river tiles on the map. It stops
-  when it has tried to create RIVERS_MAXTRIES rivers.           -Erik Sigra
-**************************************************************************/
-static void make_rivers(void)
-{
-  int x, y; /* The coordinates. */
-
-  /* Formula to make the river density similar om different sized maps. Avoids
-     too few rivers on large maps and too many rivers on small maps. */
-  int desirable_riverlength =
-    river_pct *
-      /* The size of the map (poles counted in river_pct). */
-      map_num_tiles() *
-      /* Rivers need to be on land only. */
-      map.landpercent /
-      /* Adjustment value. Tested by me. Gives no rivers with 'set
-        rivers 0', gives a reasonable amount of rivers with default
-        settings and as many rivers as possible with 'set rivers 100'. */
-      5325;
-
-  /* The number of river tiles that have been set. */
-  int current_riverlength = 0;
-
-  int i; /* Loop variable. */
-
-  /* Counts the number of iterations (should increase with 1 during
-     every iteration of the main loop in this function).
-     Is needed to stop a potentially infinite loop. */
-  int iteration_counter = 0;
-
-  create_placed_map(); /* needed bu rand_map_characteristic */
-  set_all_ocean_tiles_placed();
-
-  river_map = fc_malloc(sizeof(int) * MAX_MAP_INDEX);
-
-  /* The main loop in this function. */
-  while (current_riverlength < desirable_riverlength
-        && iteration_counter < RIVERS_MAXTRIES) {
-
-    if (!rand_map_pos_characteristic(&x, &y, 
-                                     WC_ALL, TT_NFROZEN, MC_NLOW)) {
-       break; /* mo more spring places */
-    }
-
-    /* Check if it is suitable to start a river on the current tile.
-     */
-    if (
-       /* Don't start a river on ocean. */
-       !is_ocean(map_get_terrain(x, y))
-
-       /* Don't start a river on river. */
-       && !map_has_special(x, y, S_RIVER)
-
-       /* Don't start a river on a tile is surrounded by > 1 river +
-          ocean tile. */
-       && (count_special_near_tile(x, y, TRUE, FALSE, S_RIVER)
-           + count_ocean_near_tile(x, y, TRUE, FALSE) <= 1)
-
-       /* Don't start a river on a tile that is surrounded by hills or
-          mountains unless it is hard to find somewhere else to start
-          it. */
-       && (count_terrain_near_tile(x, y, TRUE, TRUE, T_HILLS)
-           + count_terrain_near_tile(x, y, TRUE, TRUE, T_MOUNTAINS) < 90
-           || iteration_counter == RIVERS_MAXTRIES / 10 * 5)
-
-       /* Don't start a river on hills unless it is hard to find
-          somewhere else to start it. */
-       && (map_get_terrain(x, y) != T_HILLS
-           || iteration_counter == RIVERS_MAXTRIES / 10 * 6)
-
-       /* Don't start a river on mountains unless it is hard to find
-          somewhere else to start it. */
-       && (map_get_terrain(x, y) != T_MOUNTAINS
-           || iteration_counter == RIVERS_MAXTRIES / 10 * 7)
-
-       /* Don't start a river on arctic unless it is hard to find
-          somewhere else to start it. */
-       && (map_get_terrain(x, y) != T_ARCTIC
-           || iteration_counter == RIVERS_MAXTRIES / 10 * 8)
-
-       /* Don't start a river on desert unless it is hard to find
-          somewhere else to start it. */
-       && (map_get_terrain(x, y) != T_DESERT
-           || iteration_counter == RIVERS_MAXTRIES / 10 * 9)) {
-
-      /* Reset river_map before making a new river. */
-      for (i = 0; i < map.xsize * map.ysize; i++) {
-       river_map[i] = 0;
-      }
-
-      freelog(LOG_DEBUG,
-             "Found a suitable starting tile for a river at (%d, %d)."
-             " Starting to make it.",
-             x, y);
-
-      /* Try to make a river. If it is OK, apply it to the map. */
-      if (make_river(x, y)) {
-       whole_map_iterate(x1, y1) {
-         if (TEST_BIT(rmap(x1, y1), RS_RIVER)) {
-           Terrain_type_id t = map_get_terrain(x1, y1);
-
-           if (!terrain_has_flag(t, TER_CAN_HAVE_RIVER)) {
-             /* We have to change the terrain to put a river here. */
-             t = get_flag_terrain(TER_CAN_HAVE_RIVER);
-             map_set_terrain(x1, y1, t);
-           }
-           map_set_special(x1, y1, S_RIVER);
-           current_riverlength++;
-           map_set_placed(x1, y1);
-           freelog(LOG_DEBUG, "Applied a river to (%d, %d).", x1, y1);
-         }
-       } whole_map_iterate_end;
-      }
-      else {
-       freelog(LOG_DEBUG,
-               "mapgen.c: A river failed. It might have gotten stuck in a 
helix.");
-      }
-    } /* end if; */
-    iteration_counter++;
-    freelog(LOG_DEBUG,
-           "current_riverlength: %d; desirable_riverlength: %d; 
iteration_counter: %d",
-           current_riverlength, desirable_riverlength, iteration_counter);
-  } /* end while; */
-  free(river_map);
   destroy_placed_map();
-  river_map = NULL;
-}
-
-/**************************************************************************
-  make land simply does it all based on a generated heightmap
-  1) with map.landpercent it generates a ocean/grassland map 
-  2) it then calls the above functions to generate the different terrains
-**************************************************************************/
-static void make_land(void)
-{
-  
-  if (HAS_POLES) {
-    normalize_hmap_poles();
-  }
-  hmap_shore_level = (hmap_max_level * (100 - map.landpercent)) / 100;
-  ini_hmap_low_level();
-  whole_map_iterate(x, y) {
-    map_set_terrain(x, y, T_UNKNOWN); /* set as oceans count is used */
-    if (hmap(x, y) < hmap_shore_level) {
-      map_set_terrain(x, y, T_OCEAN);
-    }
-  } whole_map_iterate_end;
-  if (HAS_POLES) {
-    renormalize_hmap_poles();
-  } 
-
-  create_tmap(TRUE); /* base temperature map, need hmap and oceans */
-  
-  if (HAS_POLES) { /* this is a hack to terrains set with not frizzed oceans*/
-    make_polar_land(); /* make extra land at poles*/
-  }
-
-  create_placed_map(); /* here it means land terrains to be placed */
-  set_all_ocean_tiles_placed();
-  make_relief(); /* base relief on map */
-  make_terrains(); /* place all exept mountains and hill */
-  destroy_placed_map();
-
-  make_rivers(); /* use a new placed_map. destroy older before call */
-
-  assign_continent_numbers();
 }
 
 /**************************************************************************
@@ -986,6 +292,32 @@
 }
 
 /**************************************************************************
+ Convert parameters from the server into terrains percents parameters for
+ the generators
+**************************************************************************/
+static void adjust_terrain_param(void)
+{
+  int polar = 2 * ICE_BASE_LEVEL * map.landpercent / MAX_COLATITUDE ;
+  float factor = (100.0 - polar - map.steepness * 0.8 ) / 10000;
+
+
+  mountain_pct = factor * map.steepness * 90;
+
+  /* 40 % if wetness == 50 & */
+  forest_pct = factor * (map.wetness * 60 + 1000) ; 
+  jungle_pct = forest_pct * (MAX_COLATITUDE - TROPICAL_LEVEL) /
+               (MAX_COLATITUDE * 2);
+  forest_pct -= jungle_pct;
+
+  /* 3 - 11 % */
+  river_pct = (100 - polar) * (3 + map.wetness / 12) / 100;
+
+  /* 6 %  if wetness == 50 && temperature == 50 */
+  swamp_pct = factor * (map.wetness * 6 + map.temperature * 6);
+  desert_pct = factor * (map.temperature * 10 + (100 - map.wetness) * 10) ;
+}
+
+/**************************************************************************
   See stdinhand.c for information on map generation methods.
 
 FIXME: Some continent numbers are unused at the end of this function, fx
@@ -1032,23 +364,54 @@
       make_random_hmap(1 + SQSIZE);
     }
 
-    /* if hmap only generator make anything else */
-    if (map.generator == 1 || map.generator == 5) {
-      make_land();
+    /* if hmap only generator make anything else 
+     *
+     * TO DO: height map scenario
+     */
+    if ((map.generator == 1) || (map.generator == 5)) {
+     create_characteristics();
+      /*
+       * Second step, Initialize generalized terrains characteristics
+       */
+      characteristics_initialize_shores();
+      /* this is a hack to terrains-set with not frozen oceans*/
+      if (HAS_POLES) { 
+       characteristics_initialize_extra_polar_land();
+      }
+      characteristics_initialize_temperature(TRUE);
+      characteristics_initialize_relief();
+      characteristics_initialize_wetness(river_pct); /* and rivers */
+
+      /*
+       * 3 step, place terrians
+       */
+      make_terrains(); /* and rivers */
+      
+      assign_continent_numbers();
+
       free(height_map);
       height_map = NULL;
     }
+    /* 
+     * TODO rm it
+     */
     if (!map.tinyisles) {
       remove_tiny_islands();
     }
+
   } else {
     assign_continent_numbers();
   }
-
-  if (!temperature_is_initialized()) {
-    create_tmap(FALSE);
-  }
-  
+  /*
+   * 4 Place specials and huts
+   */
+
+  /* initialize needed characteristics if not yet done, */
+  if (!characteristics_are_initialized()) {
+      create_characteristics();
+      characteristics_initialize_temperature(FALSE);
+  } 
+ 
   /* some scenarios already provide specials */
   if (!map.have_specials) {
     add_specials(map.riches);
@@ -1058,35 +421,9 @@
     make_huts(map.huts); 
   }
 
+  destroy_characteristics();
   /* restore previous random state: */
   set_myrand_state(rstate);
-  destroy_tmap();
-}
-
-/**************************************************************************
- Convert parameters from the server into terrains percents parameters for
- the generators
-**************************************************************************/
-static void adjust_terrain_param(void)
-{
-  int polar = 2 * ICE_BASE_LEVEL * map.landpercent / MAX_COLATITUDE ;
-  float factor = (100.0 - polar - map.steepness * 0.8 ) / 10000;
-
-
-  mountain_pct = factor * map.steepness * 90;
-
-  /* 40 % if wetness == 50 & */
-  forest_pct = factor * (map.wetness * 60 + 1000) ; 
-  jungle_pct = forest_pct * (MAX_COLATITUDE - TROPICAL_LEVEL) /
-               (MAX_COLATITUDE * 2);
-  forest_pct -= jungle_pct;
-
-  /* 3 - 11 % */
-  river_pct = (100 - polar) * (3 + map.wetness / 12) / 100;
-
-  /* 6 %  if wetness == 50 && temperature == 50 */
-  swamp_pct = factor * (map.wetness * 6 + map.temperature * 6);
-  desert_pct = factor * (map.temperature * 10 + (100 - map.wetness) * 10) ;
 }
 
 /****************************************************************************
@@ -1110,7 +447,7 @@
 **************************************************************************/
 static void make_huts(int number)
 {
-  int x, y, count = 0;
+  int x, y, index, count = 0;
 
   create_placed_map(); /* here it means placed huts */
 
@@ -1118,7 +455,8 @@
 
     /* Add a hut.  But not on a polar area, on an ocean, or too close to
      * another hut. */
-    if (rand_map_pos_characteristic(&x, &y, WC_ALL, TT_NFROZEN, MC_NONE)) {
+    if (rand_index_characteristic(&index, CM_ALL, CM_NFROZEN, CM_ALL)) {
+      index_to_map_pos(&x, &y, index);
       if (is_ocean(map_get_terrain(x, y))) {
        map_set_placed(x, y); /* not good for a hut */
       } else {
@@ -1184,6 +522,20 @@
   map.have_specials = TRUE;
 }
 
+/****************************************************************************
+  Add arctic and tundra squares in the arctic zone (that is, the coolest
+  10% of the map).  We also texture the pole (adding arctic, tundra, and
+  mountains).  This is used in generators 2-4.
+****************************************************************************/
+static void make_polar(void)
+{
+  whole_map_iterate(x, y) {  
+  if (is_characteristic(map_pos_to_index(x, y), CM_FROZEN )) { 
+      map_set_terrain(x, y, T_ARCTIC);
+    }
+  } whole_map_iterate_end;
+}
+
 /**************************************************************************
   common variables for generator 2, 3 and 4
 **************************************************************************/
@@ -1249,7 +601,7 @@
     get_random_map_position_from_state(&x, &y, pstate);
 
     if (map_get_continent(x, y) == pstate->isleindex &&
-       not_placed(x, y)) {
+       map_not_placed(x, y)) {
 
       /* the first condition helps make terrain more contiguous,
         the second lets it avoid the coast: */
@@ -1273,7 +625,7 @@
          map_set_placed(x, y);
        }
       }
-      if (!not_placed(x,y)) i--;
+      if (!map_not_placed(x,y)) i--;
     }
   }
 }
@@ -1304,7 +656,7 @@
   while (i > 0 && (failsafe--) > 0) {
     get_random_map_position_from_state(&x, &y, pstate);
     if (map_get_continent(x, y) == pstate->isleindex
-       && not_placed(x, y)) {
+       && map_not_placed(x, y)) {
 
       /* the first condition helps make terrain more contiguous,
         the second lets it avoid the coast: */
@@ -1632,7 +984,8 @@
   height_map = fc_malloc(sizeof(int) * map.ysize * map.xsize);
   islands = fc_malloc((MAP_NCONT+1)*sizeof(struct isledata));
   create_placed_map(); /* land tiles which aren't placed yet */
-  create_tmap(FALSE);
+  create_characteristics();
+  characteristics_initialize_temperature(FALSE);
   
   whole_map_iterate(x, y) {
     map_set_terrain(x, y, T_OCEAN);
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/mapgen_topology.c 
freeciv_/server/generator/mapgen_topology.c
--- freeciv/server/generator/mapgen_topology.c  2004-09-17 11:14:01.000000000 
+0200
+++ freeciv_/server/generator/mapgen_topology.c 2004-09-22 17:12:04.000000000 
+0200
@@ -29,6 +29,14 @@
   functions instead (x,y) coordinate to place terrains
   colatitude is 0 at poles and MAX_COLATITUDE at equator
 ****************************************************************************/
+int colatitude (int index)
+{
+    int x, y;
+ 
+    index_to_map_pos( &x, &y, index);
+    return map_colatitude(x, y);
+}
+
 int map_colatitude(int map_x, int map_y)
 {
   double x, y;
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/mapgen_topology.h 
freeciv_/server/generator/mapgen_topology.h
--- freeciv/server/generator/mapgen_topology.h  2004-09-16 11:53:11.000000000 
+0200
+++ freeciv_/server/generator/mapgen_topology.h 2004-09-22 17:12:04.000000000 
+0200
@@ -45,6 +45,9 @@
 extern int ice_base_colatitude;
 #define ICE_BASE_LEVEL ice_base_colatitude
 
+#define HAS_POLES (map.temperature < 70 && !map.alltemperate)
+
+int colatitude (int index);
 int map_colatitude(int map_x, int map_y);
 bool near_singularity(int map_x, int map_y);
 void generator_init_topology(bool autosize);
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/utilities.c 
freeciv_/server/generator/utilities.c
--- freeciv/server/generator/utilities.c        2004-09-22 08:39:29.000000000 
+0200
+++ freeciv_/server/generator/utilities.c       2004-09-22 17:12:04.000000000 
+0200
@@ -57,11 +57,16 @@
 #define pmap(x, y) (placed_map[map_pos_to_index(x, y)])
 
 /* Checks if land has not yet been placed on pmap at (x, y) */
-bool not_placed(int x, int y)
+bool map_not_placed(int x, int y)
 {
   return !pmap((x), (y));
 }
 
+bool not_placed(int index)
+{
+  return !placed_map[index];
+}
+
 /* set has placed or not placed position in the pmap */
 void map_set_placed(int x, int y)
 {
@@ -137,6 +142,7 @@
     } whole_map_iterate_index_end;
   }
 }
+
 bool normalize_nat_pos(int *x, int  *y) 
 {
     int map_x, map_y;
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/utilities.h 
freeciv_/server/generator/utilities.h
--- freeciv/server/generator/utilities.h        2004-09-22 08:39:29.000000000 
+0200
+++ freeciv_/server/generator/utilities.h       2004-09-22 17:12:04.000000000 
+0200
@@ -81,11 +81,13 @@
 void destroy_placed_map(void);
 void map_set_placed(int x, int y);
 void map_unset_placed(int x, int y);
-bool not_placed(int x, int y);
+bool map_not_placed(int x, int y);
+bool not_placed(int index);
 bool placed_map_is_initialized(void);
 void set_all_ocean_tiles_placed(void) ;
 void set_placed_near_pos(int map_x, int map_y, int dist);
 
 
 
+
 #endif  /* FC__UTILITIES_H */

[Prev in Thread] Current Thread [Next in Thread]