Complete.Org: Mailing Lists: Archives: freeciv-dev: September 2004:
[Freeciv-Dev] (PR#10124) PATCH: new generator 1, hmap generator (1,5) mv
Home

[Freeciv-Dev] (PR#10124) PATCH: new generator 1, hmap generator (1,5) mv

[Top] [All Lists]

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index] [Thread Index]
To: undisclosed-recipients: ;
Subject: [Freeciv-Dev] (PR#10124) PATCH: new generator 1, hmap generator (1,5) mv to height_map.[ch]
From: "Marcelo Burda via RT" <mburda@xxxxxxxxx>
Date: Wed, 15 Sep 2004 02:54:36 -0700
Reply-to: RT_CorrespondAddressNotSet@xxxxxxxxxxxxxx

<URL: http://RT::WebBaseURL.not.configured:80/Ticket/Display.html?id=10124 >

> [mburda - Mer. Sep. 15 09:31:56 2004]: 
>  
 
> this one has a stupid bug but i not known why fix it  
>   
> the bug :  
> > set generator_smoth 1  
> Value must be an integer.  
>   
> help plz  
>   
> some one   
>  
Thx, this is fixed now 
diff -ruN -Xfreeciv/diff_ignore freeciv/common/map.c freeciv_/common/map.c
--- freeciv/common/map.c        2004-09-14 12:04:30.000000000 +0200
+++ freeciv_/common/map.c       2004-09-15 11:54:30.225766768 +0200
@@ -204,6 +204,7 @@
   map.riverlength           = MAP_DEFAULT_RIVERS;
   map.forestsize            = MAP_DEFAULT_FORESTS;
   map.generator             = MAP_DEFAULT_GENERATOR;
+  map.generator_smoth       = MAP_DEFAULT_GENERATOR_SMOTH;
   map.tinyisles             = MAP_DEFAULT_TINYISLES;
   map.separatepoles         = MAP_DEFAULT_SEPARATE_POLES;
   map.alltemperate          = MAP_DEFAULT_ALLTEMPERATE;
diff -ruN -Xfreeciv/diff_ignore freeciv/common/map.h freeciv_/common/map.h
--- freeciv/common/map.h        2004-09-14 12:04:30.000000000 +0200
+++ freeciv_/common/map.h       2004-09-15 12:15:14.260644720 +0200
@@ -170,6 +170,7 @@
   int riverlength;
   int forestsize;
   int generator;
+  int generator_smoth;
   bool tinyisles;
   bool separatepoles;
   bool alltemperate;
@@ -664,6 +665,10 @@
 #define MAP_MIN_GENERATOR        1
 #define MAP_MAX_GENERATOR        5
 
+#define MAP_DEFAULT_GENERATOR_SMOTH    3
+#define MAP_MIN_GENERATOR_SMOTH        1
+#define MAP_MAX_GENERATOR_SMOTH        8
+
 #define MAP_DEFAULT_TINYISLES    FALSE
 #define MAP_MIN_TINYISLES        FALSE
 #define MAP_MAX_TINYISLES        TRUE
Les fichiers freeciv/manual/civmanual et freeciv_/manual/civmanual sont 
différents.
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/height_map.c 
freeciv_/server/generator/height_map.c
--- freeciv/server/generator/height_map.c       2004-09-14 10:23:00.000000000 
+0200
+++ freeciv_/server/generator/height_map.c      2004-09-15 11:52:56.320042608 
+0200
@@ -1,5 +1,6 @@
 /********************************************************************** 
  Freeciv - Copyright (C) 2004 - Marcelo J. Burda
+           Copyright (C) 2002 - Karen Yeats for make_pseudofractal_hmap
    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)
@@ -11,5 +12,215 @@
    GNU General Public License for more details.
 ***********************************************************************/
 
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#include "map.h"
+#include "rand.h"
+
+#include "height_map.h"
+#include "mapgen_topology.h"
+#include "utilities.h" 
+
 int *height_map;
 int hmap_shore_level, hmap_mountain_level;
+/****************************************************************************
+  Lower the land near the polar region to avoid too much land there.
+
+  See also renomalize_hmap_poles
+****************************************************************************/
+void normalize_hmap_poles(void)
+{
+  whole_map_iterate(x, y) {
+    if (near_singularity(x, y)) {
+      hmap(x, y) = 0;
+    } else if (map_colatitude(x, y) < 2 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= map_colatitude(x, y) / (2.5 * ICE_BASE_LEVEL);
+    } else if (map.separatepoles 
+              && map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= 0.1;
+    } else if (map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= map_colatitude(x, y) / (2.5 * ICE_BASE_LEVEL);
+    }
+  } whole_map_iterate_end;
+}
+
+/****************************************************************************
+  Invert the effects of normalize_hmap_poles so that we have accurate heights
+  for texturing the poles.
+****************************************************************************/
+void renormalize_hmap_poles(void)
+{
+  whole_map_iterate(x, y) {
+    if (hmap(x, y) == 0 || map_colatitude(x, y) == 0) {
+      /* Nothing. */
+    } else if (map_colatitude(x, y) < 2 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= (2.5 * ICE_BASE_LEVEL) / map_colatitude(x, y);
+    } else if (map.separatepoles 
+              && map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= 10;
+    } else if (map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
+      hmap(x, y) *= (2.5 * ICE_BASE_LEVEL) /  map_colatitude(x, y);
+    }
+  } whole_map_iterate_end;
+}
+
+/**********************************************************************
+ Create uncorrelated rand map and do some call to smoth to correlate 
+ it a little and creante randoms shapes
+ **********************************************************************/
+void make_random_hmap(int smooth)
+{
+  int i = 0;
+  height_map = fc_malloc (sizeof(int) * MAX_MAP_INDEX);
+
+  INITIALIZE_ARRAY(height_map, MAX_MAP_INDEX, myrand(1000 * smooth) );
+
+  for (; i < smooth; i++) {
+    smooth_int_map(height_map, TRUE);
+  }
+
+  adjust_int_map(height_map, hmap_max_level);
+}
+
+/**************************************************************************
+  Recursive function which does the work for generator 5.
+
+  All (x0,y0) and (x1,y1) are in native coordinates.
+
+  Freeciv - Copyright (C) 2002 - Karen Yeats
+**************************************************************************/
+static void gen5rec(int step, int x0, int y0, int x1, int y1)
+{
+  int val[2][2];
+  int x1wrap = x1; /* to wrap correctly */ 
+  int y1wrap = y1; 
+
+  /* All x and y values are native. */
+
+  if (((y1 - y0 <= 0) || (x1 - x0 <= 0)) 
+      || ((y1 - y0 == 1) && (x1 - x0 == 1))) {
+    return;
+  }
+
+  if (x1 == map.xsize)
+    x1wrap = 0;
+  if (y1 == map.ysize)
+    y1wrap = 0;
+
+  val[0][0] = hnat(x0, y0);
+  val[0][1] = hnat(x0, y1wrap);
+  val[1][0] = hnat(x1wrap, y0);
+  val[1][1] = hnat(x1wrap, y1wrap);
+
+  /* set midpoints of sides to avg of side's vertices plus a random factor */
+  /* unset points are zero, don't reset if set */
+#define set_midpoints(X, Y, V)                                         \
+  do_in_map_pos(map_x, map_y, (X), (Y)) {                               \
+    if (!near_singularity(map_x, map_y)                                        
\
+       && map_colatitude(map_x, map_y) >  ICE_BASE_LEVEL/2             \
+       && hnat((X), (Y)) == 0) {                                       \
+      hnat((X), (Y)) = (V);                                            \
+    }                                                                  \
+  } do_in_map_pos_end;
+
+  set_midpoints((x0 + x1) / 2, y0,
+               (val[0][0] + val[1][0]) / 2 + myrand(step) - step / 2);
+  set_midpoints((x0 + x1) / 2,  y1wrap,
+               (val[0][1] + val[1][1]) / 2 + myrand(step) - step / 2);
+  set_midpoints(x0, (y0 + y1)/2,
+               (val[0][0] + val[0][1]) / 2 + myrand(step) - step / 2);  
+  set_midpoints(x1wrap,  (y0 + y1) / 2,
+               (val[1][0] + val[1][1]) / 2 + myrand(step) - step / 2);  
+
+  /* set middle to average of midpoints plus a random factor, if not set */
+  set_midpoints((x0 + x1) / 2, (y0 + y1) / 2,
+               ((val[0][0] + val[0][1] + val[1][0] + val[1][1]) / 4
+                + myrand(step) - step / 2));
+
+#undef set_midpoints
+
+  /* now call recursively on the four subrectangles */
+  gen5rec(2 * step / 3, x0, y0, (x1 + x0) / 2, (y1 + y0) / 2);
+  gen5rec(2 * step / 3, x0, (y1 + y0) / 2, (x1 + x0) / 2, y1);
+  gen5rec(2 * step / 3, (x1 + x0) / 2, y0, x1, (y1 + y0) / 2);
+  gen5rec(2 * step / 3, (x1 + x0) / 2, (y1 + y0) / 2, x1, y1);
+}
+
+/**************************************************************************
+Generator 5 makes earthlike worlds with one or more large continents and
+a scattering of smaller islands. It does so by dividing the world into
+blocks and on each block raising or lowering the corners, then the 
+midpoints and middle and so on recursively.  Fiddling with 'xdiv' and 
+'ydiv' will change the size of the initial blocks and, if the map does not 
+wrap in at least one direction, fiddling with 'avoidedge' will change the 
+liklihood of continents butting up to non-wrapped edges.
+
+  All X and Y values used in this function are in native coordinates.
+
+ Freeciv - Copyright (C) 2002 - Karen Yeats
+**************************************************************************/
+void make_pseudofractal1_hmap(void)
+{
+  const bool xnowrap = !topo_has_flag(TF_WRAPX);
+  const bool ynowrap = !topo_has_flag(TF_WRAPY);
+
+  /* 
+   * How many blocks should the x and y directions be divided into
+   * initially. 
+   */
+  const int xdiv = 6;          
+  const int ydiv = 5;
+
+  int xdiv2 = xdiv + (xnowrap ? 1 : 0);
+  int ydiv2 = ydiv + (ynowrap ? 1 : 0);
+
+  int xmax = map.xsize - (xnowrap ? 1 : 0);
+  int ymax = map.ysize - (ynowrap ? 1 : 0);
+  int xn, yn;
+  /* just need something > log(max(xsize, ysize)) for the recursion */
+  int step = map.xsize + map.ysize; 
+  /* edges are avoided more strongly as this increases */
+  int avoidedge = (50 - map.landpercent) * step / 100 + step / 3; 
+
+  height_map = fc_malloc(sizeof(int) * MAX_MAP_INDEX);
+
+ /* initialize map */
+  INITIALIZE_ARRAY(height_map, MAX_MAP_INDEX, 0);
+
+  /* set initial points */
+  for (xn = 0; xn < xdiv2; xn++) {
+    for (yn = 0; yn < ydiv2; yn++) {
+      do_in_map_pos(x, y, (xn * xmax / xdiv), (yn * ymax / ydiv)) {
+       /* set initial points */
+       hmap(x, y) = myrand(2 * step) - (2 * step) / 2;
+
+       if (near_singularity(x, y)) {
+         /* avoid edges (topological singularities) */
+         hmap(x, y) -= avoidedge;
+       }
+
+       if (map_colatitude(x, y) <= ICE_BASE_LEVEL / 2 ) {
+         /* separate poles and avoid too much land at poles */
+         hmap(x, y) -= myrand(avoidedge);
+       }
+      } do_in_map_pos_end;
+    }
+  }
+
+  /* calculate recursively on each block */
+  for (xn = 0; xn < xdiv; xn++) {
+    for (yn = 0; yn < ydiv; yn++) {
+      gen5rec(step, xn * xmax / xdiv, yn * ymax / ydiv, 
+             (xn + 1) * xmax / xdiv, (yn + 1) * ymax / ydiv);
+    }
+  }
+
+  /* put in some random fuzz */
+  whole_map_iterate(x, y) {
+    hmap(x, y) = 8 * hmap(x, y) + myrand(4) - 2;
+  } whole_map_iterate_end;
+
+  adjust_int_map(height_map, hmap_max_level);
+}
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/height_map.h 
freeciv_/server/generator/height_map.h
--- freeciv/server/generator/height_map.h       2004-09-14 10:23:00.000000000 
+0200
+++ freeciv_/server/generator/height_map.h      2004-09-15 11:52:39.487601528 
+0200
@@ -1,5 +1,6 @@
 /********************************************************************** 
  Freeciv - Copyright (C) 2004 - Marcelo J. Burda
+           Copyright (C) 2002 - Karen Yeats for make_pseudofractal_hmap
    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)
@@ -35,4 +36,9 @@
 extern int *height_map;
 extern int hmap_shore_level, hmap_mountain_level;
 
+void normalize_hmap_poles(void);
+void renormalize_hmap_poles(void);
+void make_random_hmap(int smooth);
+void make_pseudofractal1_hmap(void);
+
 #endif  /* FC__HEIGHT__MAP_H */
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/mapgen.c 
freeciv_/server/generator/mapgen.c
--- freeciv/server/generator/mapgen.c   2004-09-14 12:04:31.000000000 +0200
+++ freeciv_/server/generator/mapgen.c  2004-09-15 11:47:29.190773816 +0200
@@ -50,12 +50,9 @@
 
 static void make_huts(int number);
 static void add_specials(int prob);
-static void mapgenerator1(void);
 static void mapgenerator2(void);
 static void mapgenerator3(void);
 static void mapgenerator4(void);
-static void mapgenerator5(void);
-static void smooth_map(void);
 static void adjust_terrain_param(void);
 
 #define RIVERS_MAXTRIES 32767
@@ -917,47 +914,6 @@
   river_map = NULL;
 }
 
-/****************************************************************************
-  Lower the land near the polar region to avoid too much land there.
-
-  See also renomalize_hmap_poles
-****************************************************************************/
-static void normalize_hmap_poles(void)
-{
-  whole_map_iterate(x, y) {
-    if (near_singularity(x, y)) {
-      hmap(x, y) = 0;
-    } else if (map_colatitude(x, y) < 2 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= map_colatitude(x, y) / (2.5 * ICE_BASE_LEVEL);
-    } else if (map.separatepoles 
-              && map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= 0.1;
-    } else if (map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= map_colatitude(x, y) / (2.5 * ICE_BASE_LEVEL);
-    }
-  } whole_map_iterate_end;
-}
-
-/****************************************************************************
-  Invert the effects of normalize_hmap_poles so that we have accurate heights
-  for texturing the poles.
-****************************************************************************/
-static void renormalize_hmap_poles(void)
-{
-  whole_map_iterate(x, y) {
-    if (hmap(x, y) == 0 || map_colatitude(x, y) == 0) {
-      /* Nothing. */
-    } else if (map_colatitude(x, y) < 2 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= (2.5 * ICE_BASE_LEVEL) / map_colatitude(x, y);
-    } else if (map.separatepoles 
-              && map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= 10;
-    } else if (map_colatitude(x, y) <= 2.5 * ICE_BASE_LEVEL) {
-      hmap(x, y) *= (2.5 * ICE_BASE_LEVEL) /  map_colatitude(x, y);
-    }
-  } whole_map_iterate_end;
-}
-
 /**************************************************************************
   make land simply does it all based on a generated heightmap
   1) with map.landpercent it generates a ocean/grassland map 
@@ -965,7 +921,7 @@
 **************************************************************************/
 static void make_land(void)
 {
-  adjust_int_map(height_map, hmap_max_level);
+  
   if (HAS_POLES) {
     normalize_hmap_poles();
   }
@@ -1325,16 +1281,26 @@
     adjust_terrain_param();
     /* if one mapgenerator fails, it will choose another mapgenerator */
     /* with a lower number to try again */
-    if (map.generator == 5 )
-      mapgenerator5();
+    if (map.generator == 5 ) {
+      make_pseudofractal1_hmap();
+    }
     if (map.generator == 4 )
       mapgenerator4();
     if (map.generator == 3 )
       mapgenerator3();
-    if( map.generator == 2 )
+    if (map.generator == 2 )
       mapgenerator2();
-    if( map.generator == 1 )
-      mapgenerator1();
+    if (map.generator == 1 ) {
+      make_random_hmap(map.generator_smoth);
+    }
+
+    /* if hmap only genrator make any thing else */
+    if (map.generator == 1 || map.generator == 5) {
+      make_land();
+      free(height_map);
+      height_map = NULL;
+    }
+
     if (!map.tinyisles) {
       remove_tiny_islands();
     }
@@ -1379,82 +1345,6 @@
   }
 }
 
-/**************************************************************************
-  mapgenerator1, highlevel function, that calls all the previous functions
-**************************************************************************/
-static void mapgenerator1(void)
-{
-  int i;
-  height_map = fc_malloc (sizeof(int) * MAX_MAP_INDEX);
-
-  INITIALIZE_ARRAY(height_map, MAX_MAP_INDEX, myrand(40) );
-
-  for (i=0;i<1500;i++) {
-    int x, y;
-
-    rand_map_pos(&x, &y);
-
-    if (near_singularity(x, y)
-       || map_colatitude(x, y) <= ICE_BASE_LEVEL / 2) { 
-      /* Avoid land near singularities or at the poles. */
-      hmap(x, y) -= myrand(5000);
-    } else { 
-      hmap(x, y) += myrand(5000);
-    }
-    if ((i % 100) == 0) {
-      smooth_map(); 
-    }
-  }
-
-  smooth_map(); 
-  smooth_map(); 
-  smooth_map(); 
-
-  make_land();
-  free(height_map);
-  height_map = NULL;
-}
-
-/**************************************************************************
-  smooth_map should be viewed as a corrosion function on the map, it
-  levels out the differences in the heightmap.
-**************************************************************************/
-static void smooth_map(void)
-{
-  /* We make a new height map and then copy it back over the old one.
-   * Care must be taken so that the new height map uses the exact same
-   * storage structure as the real one - it must be the same size and
-   * use the same indexing. The advantage of the new array is there's
-   * no feedback from overwriting in-use values.
-   */
-  int *new_hmap = fc_malloc(sizeof(int) * map.xsize * map.ysize);
-  
-  whole_map_iterate(x, y) {
-    /* double-count this tile */
-    int height_sum = hmap(x, y) * 2;
-
-    /* weight of counted tiles */
-    int counter = 2;
-
-    adjc_iterate(x, y, x2, y2) {
-      /* count adjacent tile once */
-      height_sum += hmap(x2, y2);
-      counter++;
-    } adjc_iterate_end;
-
-    /* random factor: -30..30 */
-    height_sum += myrand(61) - 30;
-
-    if (height_sum < 0)
-      height_sum = 0;
-    new_hmap[map_pos_to_index(x, y)] = height_sum / counter;
-  } whole_map_iterate_end;
-
-  memcpy(height_map, new_hmap, sizeof(int) * map.xsize * map.ysize);
-  free(new_hmap);
-}
-
-
 /****************************************************************************
   Return TRUE if a safe tile is in a radius of 1.  This function is used to
   test where to place specials on the sea.
@@ -2275,142 +2165,3 @@
 }
 
 #undef DMSIS
-
-/**************************************************************************
-  Recursive function which does the work for generator 5.
-
-  All (x0,y0) and (x1,y1) are in native coordinates.
-**************************************************************************/
-static void gen5rec(int step, int x0, int y0, int x1, int y1)
-{
-  int val[2][2];
-  int x1wrap = x1; /* to wrap correctly */ 
-  int y1wrap = y1; 
-
-  /* All x and y values are native. */
-
-  if (((y1 - y0 <= 0) || (x1 - x0 <= 0)) 
-      || ((y1 - y0 == 1) && (x1 - x0 == 1))) {
-    return;
-  }
-
-  if (x1 == map.xsize)
-    x1wrap = 0;
-  if (y1 == map.ysize)
-    y1wrap = 0;
-
-  val[0][0] = hnat(x0, y0);
-  val[0][1] = hnat(x0, y1wrap);
-  val[1][0] = hnat(x1wrap, y0);
-  val[1][1] = hnat(x1wrap, y1wrap);
-
-  /* set midpoints of sides to avg of side's vertices plus a random factor */
-  /* unset points are zero, don't reset if set */
-#define set_midpoints(X, Y, V)                                         \
-  do_in_map_pos(map_x, map_y, (X), (Y)) {                               \
-    if (!near_singularity(map_x, map_y)                                        
\
-       && map_colatitude(map_x, map_y) >  ICE_BASE_LEVEL/2             \
-       && hnat((X), (Y)) == 0) {                                       \
-      hnat((X), (Y)) = (V);                                            \
-    }                                                                  \
-  } do_in_map_pos_end;
-
-  set_midpoints((x0 + x1) / 2, y0,
-               (val[0][0] + val[1][0]) / 2 + myrand(step) - step / 2);
-  set_midpoints((x0 + x1) / 2,  y1wrap,
-               (val[0][1] + val[1][1]) / 2 + myrand(step) - step / 2);
-  set_midpoints(x0, (y0 + y1)/2,
-               (val[0][0] + val[0][1]) / 2 + myrand(step) - step / 2);  
-  set_midpoints(x1wrap,  (y0 + y1) / 2,
-               (val[1][0] + val[1][1]) / 2 + myrand(step) - step / 2);  
-
-  /* set middle to average of midpoints plus a random factor, if not set */
-  set_midpoints((x0 + x1) / 2, (y0 + y1) / 2,
-               ((val[0][0] + val[0][1] + val[1][0] + val[1][1]) / 4
-                + myrand(step) - step / 2));
-
-#undef set_midpoints
-
-  /* now call recursively on the four subrectangles */
-  gen5rec(2 * step / 3, x0, y0, (x1 + x0) / 2, (y1 + y0) / 2);
-  gen5rec(2 * step / 3, x0, (y1 + y0) / 2, (x1 + x0) / 2, y1);
-  gen5rec(2 * step / 3, (x1 + x0) / 2, y0, x1, (y1 + y0) / 2);
-  gen5rec(2 * step / 3, (x1 + x0) / 2, (y1 + y0) / 2, x1, y1);
-}
-
-/**************************************************************************
-Generator 5 makes earthlike worlds with one or more large continents and
-a scattering of smaller islands. It does so by dividing the world into
-blocks and on each block raising or lowering the corners, then the 
-midpoints and middle and so on recursively.  Fiddling with 'xdiv' and 
-'ydiv' will change the size of the initial blocks and, if the map does not 
-wrap in at least one direction, fiddling with 'avoidedge' will change the 
-liklihood of continents butting up to non-wrapped edges.
-
-  All X and Y values used in this function are in native coordinates.
-**************************************************************************/
-static void mapgenerator5(void)
-{
-  const bool xnowrap = !topo_has_flag(TF_WRAPX);
-  const bool ynowrap = !topo_has_flag(TF_WRAPY);
-
-  /* 
-   * How many blocks should the x and y directions be divided into
-   * initially. 
-   */
-  const int xdiv = 6;          
-  const int ydiv = 5;
-
-  int xdiv2 = xdiv + (xnowrap ? 1 : 0);
-  int ydiv2 = ydiv + (ynowrap ? 1 : 0);
-
-  int xmax = map.xsize - (xnowrap ? 1 : 0);
-  int ymax = map.ysize - (ynowrap ? 1 : 0);
-  int xn, yn;
-  /* just need something > log(max(xsize, ysize)) for the recursion */
-  int step = map.xsize + map.ysize; 
-  /* edges are avoided more strongly as this increases */
-  int avoidedge = (50 - map.landpercent) * step / 100 + step / 3; 
-
-  height_map = fc_malloc(sizeof(int) * MAX_MAP_INDEX);
-
- /* initialize map */
-  INITIALIZE_ARRAY(height_map, MAX_MAP_INDEX, 0);
-
-  /* set initial points */
-  for (xn = 0; xn < xdiv2; xn++) {
-    for (yn = 0; yn < ydiv2; yn++) {
-      do_in_map_pos(x, y, (xn * xmax / xdiv), (yn * ymax / ydiv)) {
-       /* set initial points */
-       hmap(x, y) = myrand(2 * step) - (2 * step) / 2;
-
-       if (near_singularity(x, y)) {
-         /* avoid edges (topological singularities) */
-         hmap(x, y) -= avoidedge;
-       }
-
-       if (map_colatitude(x, y) <= ICE_BASE_LEVEL / 2 ) {
-         /* separate poles and avoid too much land at poles */
-         hmap(x, y) -= myrand(avoidedge);
-       }
-      } do_in_map_pos_end;
-    }
-  }
-
-  /* calculate recursively on each block */
-  for (xn = 0; xn < xdiv; xn++) {
-    for (yn = 0; yn < ydiv; yn++) {
-      gen5rec(step, xn * xmax / xdiv, yn * ymax / ydiv, 
-             (xn + 1) * xmax / xdiv, (yn + 1) * ymax / ydiv);
-    }
-  }
-
-  /* put in some random fuzz */
-  whole_map_iterate(x, y) {
-    hmap(x, y) = 8 * hmap(x, y) + myrand(4) - 2;
-  } whole_map_iterate_end;
-
-  make_land();
-  free(height_map);
-  height_map = NULL;
-}
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/utilities.c 
freeciv_/server/generator/utilities.c
--- freeciv/server/generator/utilities.c        2004-09-14 10:23:00.000000000 
+0200
+++ freeciv_/server/generator/utilities.c       2004-09-15 11:06:35.663766616 
+0200
@@ -134,3 +134,88 @@
     }
   }
 }
+bool normalize_nat_pos(int *x, int  *y) 
+{
+    int map_x, map_y;
+    bool return_value;
+
+    NATIVE_TO_MAP_POS(&map_x, &map_y, *x, *y);
+    return_value = normalize_map_pos(&map_x, &map_y);
+    MAP_TO_NATIVE_POS(x, y, map_x, map_y);
+
+    return return_value;
+}
+
+bool is_normal_nat_pos(int x, int y)
+{
+  do_in_map_pos(map_x, map_y, x, y) {
+    return is_normal_map_pos(map_x, map_y);
+  } do_in_map_pos_end;
+}
+
+#define iterate_axe(x, y, i, x0, y0, dist, Xaxe) \
+{ \
+    int x, y, i; \
+ \
+    for (i = -(dist); i <= (dist); i++) { \
+       x = x0 + (Xaxe ? i : 0); \
+       y = y0 + (Xaxe ? 0 : i); \
+       if(!normalize_nat_pos(&x, &y)) { \
+           continue; \
+       } 
+
+#define iterate_axe_end \      
+    } \
+} 
+/**************************************************************************
+ * Apply a difusion filtre on the map
+ * we assume the size is MAX_MAP_INDEX and is indexed has the main map
+ * native_to_index is used! 
+ * code assume out map value of 0 if zeroes_at_edges is set. else code dont't 
+ * diffuse from outside the real map.
+ * the filter is a Gaussian difusion 
+ * aproximated by -2..+2 tiles finite math
+ ****************************************************************************/
+ void smooth_int_map(int *int_map, bool zeroes_at_edges)
+{
+  assert(int_map != NULL);
+  float weight[5] =  {0.35,  0.5 ,1 , 0.5, 0.35};
+  float total_weight = 2.70;
+  int x, y;
+  bool axe = TRUE;
+  int alt_int_map[MAX_MAP_INDEX];
+  int *target_map, *source_map;
+
+  target_map = alt_int_map;
+  source_map = int_map;
+
+  do {
+    for (y = 0; y < map.ysize; y++) {
+      for (x = 0; x < map.xsize; x++) {
+         int  N = 0, D = 0;
+         iterate_axe(x1, y1, i, x, y, 2, axe) {
+             D += weight[i + 2];
+             N += weight[i + 2] * source_map[native_pos_to_index(x1, y1)];
+         } iterate_axe_end;
+         if(zeroes_at_edges) {
+           D = total_weight;
+         }
+         target_map[native_pos_to_index(x, y)] = N / D;
+         
+      }
+    }
+
+  if (topo_has_flag(TF_ISO) || topo_has_flag(TF_HEX)) {
+    weight[0] = weight[4] = 0.5;
+    weight[1] = weight[3] = 0.7;
+    total_weight = 3.4;  
+  }
+
+  axe = !axe;
+
+  source_map = alt_int_map;
+  target_map = int_map;
+
+  } while ( !axe );
+}
+
diff -ruN -Xfreeciv/diff_ignore freeciv/server/generator/utilities.h 
freeciv_/server/generator/utilities.h
--- freeciv/server/generator/utilities.h        2004-09-14 10:23:00.000000000 
+0200
+++ freeciv_/server/generator/utilities.h       2004-09-14 21:56:01.000000000 
+0200
@@ -30,6 +30,39 @@
   }                                                                         \
 }
 
+/* Provide a block to convert from map to native coordinates.  This allows
+ * you to use a native version of the map position within the block.  Note
+ * that the native position is declared as const and can't be changed
+ * inside the block. */
+#define index_do_in_native_pos(nat_x, nat_y, index)                        \
+{                                                                           \
+  int _nat_x, _nat_y;                                                       \
+  index_to_native_pos(&_nat_x, &_nat_y, map_x, map_y);                     \
+  {                                                                         \
+    const int nat_x = _nat_x, nat_y = _nat_y;
+
+#define index_do_in_native_pos_end                                             
   \
+  }                                                                         \
+}
+
+/* Provide a block to convert from map to natural coordinates. This allows
+ * you to use a natural version of the map position within the block.  Note
+ * that the natural position is declared as const and can't be changed
+ * inside the block. */
+#define index_do_in_natural_pos(ntl_x, ntl_y, index)                        \
+{                                                                           \
+  int _ntl_x, _ntl_y;                                                       \
+  index_to_natural_pos(&_ntl_x, &_ntl_y, index);                           \
+  {                                                                         \
+    const int ntl_x = _ntl_x, ntl_y = _ntl_y;
+
+#define do_in_natural_pos_end                                                \
+  }                                                                         \
+}
+
+bool normalize_nat_pos(int *x, int  *y);
+bool is_normal_nat_pos(int x, int y);
+
 void adjust_int_map(int *int_map, int int_map_max);
 void create_placed_map(void);
 void destroy_placed_map(void);
@@ -39,6 +72,7 @@
 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);
+void smooth_int_map(int *int_map, bool zeroes_at_edges);
 
 
 #endif  /* FC__UTILITIES_H */
diff -ruN -Xfreeciv/diff_ignore freeciv/server/savegame.c 
freeciv_/server/savegame.c
--- freeciv/server/savegame.c   2004-09-14 12:04:31.000000000 +0200
+++ freeciv_/server/savegame.c  2004-09-15 12:09:42.516077560 +0200
@@ -3093,6 +3093,9 @@
       map.riches = secfile_lookup_int(file, "map.riches");
       map.huts = secfile_lookup_int(file, "map.huts");
       map.generator = secfile_lookup_int(file, "map.generator");
+      map.generator_smoth =
+         secfile_lookup_int_default(file,
+                      MAP_DEFAULT_GENERATOR_SMOTH, "map.generator_smoth");
       map.seed = secfile_lookup_int(file, "map.seed");
       map.landpercent = secfile_lookup_int(file, "map.landpercent");
       map.grasssize =
@@ -3485,6 +3488,7 @@
     secfile_insert_int(file, map.forestsize, "map.forestsize");
     secfile_insert_int(file, map.huts, "map.huts");
     secfile_insert_int(file, map.generator, "map.generator");
+    secfile_insert_int(file, map.generator_smoth, "map.generator_smoth");
     secfile_insert_bool(file, map.have_huts, "map.have_huts");
     secfile_insert_int(file, map.temperature, "map.temperature");
     secfile_insert_bool(file, map.alltemperate, "map.alltemperate");
diff -ruN -Xfreeciv/diff_ignore freeciv/server/settings.c 
freeciv_/server/settings.c
--- freeciv/server/settings.c   2004-09-14 12:04:31.000000000 +0200
+++ freeciv_/server/settings.c  2004-09-15 12:51:29.264993800 +0200
@@ -274,6 +274,16 @@
             "(Zero indicates a scenario map.)"), NULL,
          MAP_MIN_GENERATOR, MAP_MAX_GENERATOR, MAP_DEFAULT_GENERATOR)
 
+  GEN_INT("generatorsmoth", map.generator_smoth,
+         SSET_MAP_GEN, SSET_GEOLOGY, SSET_VITAL,  SSET_TO_CLIENT,
+         N_("number of smoth passes for random generator 1"),
+         N_("1 = do small continents and islands with irregular shore,"
+            " nice in small maps;\n\n"
+            "3 = default value wiht medium continents ;\n\n"
+            "8 = big continents, only nice for huges maps.\n\n"), NULL,
+         MAP_MIN_GENERATOR_SMOTH, MAP_MAX_GENERATOR_SMOTH,
+          MAP_DEFAULT_GENERATOR_SMOTH)
+
   GEN_BOOL("tinyisles", map.tinyisles,
           SSET_MAP_GEN, SSET_GEOLOGY, SSET_RARE, SSET_TO_CLIENT,
           N_("Presence of 1x1 islands"),

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