Refined mountain-levels.

Altitude-factor for temperature-calculation makes use of the new levels.
River-generation makes use of the new levels.
Ancient map-generation makes use of the new levels.

Author: tcld

worldengine/drawing_functions.py

@@ -100,10 +100,10 @@ def _find_mountains_mask(world, factor):
     _mask = numpy.zeros((factor * world.height, factor * world.width), dtype=float)
     for y in range(factor * world.height):
         for x in range(factor * world.width):
-            if world.is_mountain((int(x / factor), int(y / factor))):
+            if world.is_low_mountain((int(x / factor), int(y / factor)), atleast=True):  # maybe use is_medium_mountain()?
                 v = len(world.tiles_around((int(x / factor), int(y / factor)),
                                            radius=3,
-                                           predicate=world.is_mountain))
+                                           predicate=lambda pos: world.is_low_mountain(pos, atleast=True)))
                 if v > 32:
                     _mask[y, x] = v / 4.0  # force conversion to float, Python 2 will *not* do it automatically
     return _mask

worldengine/generation.py

@@ -105,11 +105,14 @@ def initialize_ocean_and_thresholds(world, ocean_level=1.0):
     """
     e = world.elevation['data']
     ocean = fill_ocean(e, ocean_level)
-    pl = find_threshold_f(e, 0.70, ocean=ocean)  # the highest x% of land are declared plains
-    hl = find_threshold_f(e, 0.35, ocean=ocean)  # the highest x% are declared hills
-    ml = find_threshold_f(e, 0.10, ocean=ocean)  # the highest x% are declared low mountains
-    mml = find_threshold_f(e, 0.06, ocean=ocean)  # the highest x% are declared medium mountains
-    hml = find_threshold_f(e, 0.02, ocean=ocean)  # the highest x% are declared high mountains
+
+    # values chosen to emulate the exponential behavior seen here:
+    # http://www.ngdc.noaa.gov/mgg/global/etopo1_surface_histogram.html
+    pl = find_threshold_f(e, 0.95, ocean=ocean)  # the highest x% of land are declared plains; save some for beaches (?)
+    hl = find_threshold_f(e, 0.50, ocean=ocean)  # the highest x% are declared hills
+    ml = find_threshold_f(e, 0.25, ocean=ocean)  # the highest x% are declared low mountains
+    mml = find_threshold_f(e, 0.12, ocean=ocean)  # the highest x% are declared medium mountains
+    hml = find_threshold_f(e, 0.06, ocean=ocean)  # the highest x% are declared high mountains
     e_th = [('sea', ocean_level),
             ('plain', pl),
             ('hill', hl),

worldengine/simulations/erosion.py

@@ -152,9 +152,7 @@ def river_sources(world, water_flow, water_path):
                 while not neighbour_seed_found:
 
                     # have we found a seed?
-                    if world.is_mountain((cx, cy)) and \
-                            water_flow[cy, cx] >= RIVER_TH:
-
+                    if world.is_low_mountain((cx, cy), atleast=True) and water_flow[cy, cx] >= RIVER_TH:
                         # try not to create seeds around other seeds
                         for seed in river_source_list:
                             sx, sy = seed

worldengine/simulations/temperature.py

@@ -10,11 +10,9 @@ def is_applicable(world):
         return not world.has_temperature()
 
     def execute(self, world, seed):
-        e = world.elevation['data']
-        ml = world.start_mountain_th()  # returns minimum elevation value for mountains (i.e. hills)
         ocean = world.ocean
 
-        t = self._calculate(world, seed, e, ml)
+        t = self._calculate(world, seed)
         t_th = [
             ('polar', find_threshold_f(t, world.temps[0], ocean)),
             ('alpine', find_threshold_f(t, world.temps[1], ocean)),
@@ -27,13 +25,18 @@ def execute(self, world, seed):
         world.set_temperature(t, t_th)
 
     @staticmethod
-    def _calculate(world, seed, elevation, mountain_level):
+    def _calculate(world, seed):
         width = world.width
         height = world.height
+        e = world.elevation['data']
+        mountain_level = world.start_mountain_th()  # returns minimum elevation value for mountains (i.e. hills)
+        highest_mountain_level = e.max() # world.level_of_mountain(numpy.unravel_index(e.argmax(), e.shape))  # height of the highest point relative to mountain_level
 
         rng = numpy.random.RandomState(seed)  # create our own random generator
         base = rng.randint(0, 4096)
         temp = numpy.zeros((height, width), dtype=float)
+        
+        min_altitude_factor = 0.3  # used for the top of the highest mountain; must be in [0, 1]
 
         '''
         Set up variables to take care of some orbital parameters:
@@ -89,13 +92,8 @@ def _calculate(world, seed, elevation, mountain_level):
                                    base=base) * (border - x) / border)
 
                 t = (latitude_factor * 12 + n * 1) / 13.0 / distance_to_sun
-                if elevation[y, x] > mountain_level:  # vary temperature based on height
-                    if elevation[y, x] > (mountain_level + 29):
-                        altitude_factor = 0.033
-                    else:
-                        altitude_factor = 1.00 - (
-                            float(elevation[y, x] - mountain_level) / 30)
-                    t *= altitude_factor
-                temp[y, x] = t
+
+                # vary temperature based on height
+                temp[y, x] = t * numpy.interp(e[y, x], [mountain_level, highest_mountain_level], [1.00, min_altitude_factor])
 
         return temp

worldengine/world.py

@@ -430,35 +430,47 @@ def is_mountain(self, pos):  # general test
         x, y = pos
         return mountain_level <= self.elevation['data'][y, x]
 
-    def is_hill(self, pos):
+    def is_hill(self, pos, atleast=False):
         if self.ocean[pos[1], pos[0]]:
             return False
         hill_level = self.elevation['thresholds'][2][1]
         low_mountain_level = self.elevation['thresholds'][3][1]
         x, y = pos
-        return hill_level <= self.elevation['data'][y, x] < low_mountain_level
+        if atleast:
+            return hill_level <= self.elevation['data'][y, x]
+        else:
+            return hill_level <= self.elevation['data'][y, x] < low_mountain_level
 
-    def is_low_mountain(self, pos):
+    def is_low_mountain(self, pos, atleast=False):
         if self.ocean[pos[1], pos[0]]:
             return False
         low_mountain_level = self.elevation['thresholds'][3][1]
         mountain_level = self.elevation['thresholds'][4][1]
         x, y = pos
-        return low_mountain_level <= self.elevation['data'][y, x] < mountain_level
+        if atleast:
+            return low_mountain_level <= self.elevation['data'][y, x]
+        else:
+            return low_mountain_level <= self.elevation['data'][y, x] < mountain_level
 
-    def is_medium_mountain(self, pos):
+    def is_medium_mountain(self, pos, atleast=False):
         if self.ocean[pos[1], pos[0]]:
             return False
         mountain_level = self.elevation['thresholds'][4][1]
         high_mountain_level = self.elevation['thresholds'][5][1]
         x, y = pos
-        return mountain_level <= self.elevation['data'][y, x] < high_mountain_level
+        if atleast:
+            return mountain_level <= self.elevation['data'][y, x]
+        else:
+            return mountain_level <= self.elevation['data'][y, x] < high_mountain_level
 
-    def is_high_mountain(self, pos):
+    def is_high_mountain(self, pos, atleast=False):
+        # atleast is not used here (there is no higher threshold anyway); it is there to give all functions of this type the same signature
         if self.ocean[pos[1], pos[0]]:
             return False
         high_mountain_level = self.elevation['thresholds'][5][1]
         x, y = pos
+        if atleast:
+            pass
         return high_mountain_level <= self.elevation['data'][y, x]
 
     def level_of_mountain(self, pos):