temperature affected by latitude, non-linearly

ReadMe.md

@@ -8,14 +8,22 @@ Using the heightmap generator from here: https://github.com/TangentFoxy/heightma
 - [ ] Remove heightmap library
   - [ ] Update ReadMe
   - [ ] ReadMe should also point out where the simplex implementation comes from
-- [ ] Update the `simplex` library to the latest version with FBM
+- [x] Update the `simplex` library to the latest version with FBM
-- [ ] Round the new map generator to a planet shape
+- [x] Round the new map generator to a planet shape
 - [ ] Move `tile_size` out of the map generator (this is a render feature, not a map feature)
-- [ ] Turn the new map gen into a wrapper kind of like my heightmap wrapper? (This is sorta already done in a sloppy way.)
+- [x] Turn the new map gen into a wrapper kind of like my heightmap wrapper? (This is sorta already done in a sloppy way.)
 - [ ] Rebuild the multi-noise map system.
   - [ ] Renormalize to Earth extremes. :D (This will probably give bad initial results and need extensive changes.)
-  - [ ] Use a spreadsheet to map -0.9 to 0.9 to find a mapping function to modify initial values to realistic height ranges!
+  - [x] Use a spreadsheet to map -0.9 to 0.9 to find a mapping function to modify initial values to realistic height ranges!
-  - [ ] Rename `humidity` to `rainfall`.
+    (This was done with -1 to 1)
+  - [x] Rename `humidity` to `rainfall`.
 - [ ] make documentation of how this is all working so I can remember when I forget to work on it for a while
 
+### Long-Term
+- [ ] Do all terrain generation within a radius check so unnecessary work isn't done and discarded.
+  - [ ] Terrain generation steps should happen within a single loop wherever possible?
+
+## Reference
+- Out of 52 seeds randomly tested, the current code creates a temperature range between -80.64 and 33.78 C.
+
 (Tasks/Issues are stored in the ReadMe instead of using a webUI issue tracker due to how using such a tracker negatively influences portability of the project.)

disorganized biome notes.txt

@@ -0,0 +1,62 @@
+DDG summary:
+aquatic -> freshwater / marine,
+grassland (2nd largest?),
+forest -> tropical / temperate,
+desert,
+tundra,
+
+---
+
+Wikipedia:
+ice sheet / polar desert,
+tundra (tree growth hindered by cold and short growing seasons; arctic, alpine, antarctic; shrubs, grasses, mosses, lichen; soil high N & P, biomass, methane, CO2, permafrost),
+taiga (boreal forest, snow forest, coniferous forest; pines, spruces, larches; largest land biome),
+temperate broadleaf forest,
+temperate steppe and savanna,
+subtropical evergreen forest,
+Mediterranean vegetation,
+monsoon forests and mosaic,
+arid desert,
+xeric shrubland,
+dry steppe and thorn forest,
+semiarid desert,
+grass savanna,
+tree savanna,
+dry forest and woodland savanna,
+tropical rainforest (evergreen?),
+alpine tundra,
+montane forests and grasslands,
+- what variables control whether it develops a forest or grassland?
+
+alts:
+deciduous forest (not evergreen - can be cold or dry to cause leaves to fall; trees, shrubs, perennials),
+high plateaus (flat raised plains),
+
+---
+
+savanna seems to just mean grassland with some shrubs and trees? (dry)
+steppe is grasslands with NO trees (dry, often cold)
+meadow is wet grasslands
+hypoxic / anoxic waters FORM dead zones (nutrient concentration -> bloom, low water movement, high temperature; deepest waters?), gyre centers (ocean currents)
+- use of absolute deepest water as a shortcut should be fine,
+- use of highest temperature in water would also be a decent shortcut
+
+("continentalness" may be useful)
+
+tropical just means low latitude - these are small
+montane just means mountain
+
+(one mm of rainfall == 1 L/m^3)
+
+---
+
+coastal forest? (tropical moist broadleaf)
+montanes are often forested?
+what's the difference between a swamp and marsh? and bog?
+I should sprinkle volcanoes in (but that would work better with some kind of fault sim)
+- these form jungle/forest easier? more nutrients in soil
+what's a moorland?
+jungle vs rainforest?
+
+rifts and rivers?
+temperature should decrease by 0.0065 per meter (but this only holds above water?)

src/lib/running_average.lua

@@ -0,0 +1,27 @@
+local running_average = {
+  trackers = {}
+}
+
+local trackers = running_average.trackers
+
+running_average.track = function(name, value)
+  if not trackers[name] then
+    trackers[name] = { running_total = 0, count = 0, }
+  end
+  local track = trackers[name]
+
+  track.running_total = track.running_total + value
+  track.count = track.count + 1
+
+  return track.running_total / track.count
+end
+
+running_average.average = function(name)
+  return trackers[name] and trackers[name].running_total / trackers[name].count
+end
+
+running_average.count = function(name)
+  return trackers[name] and trackers[name].count
+end
+
+return running_average

src/lib/simplex.lua

@@ -556,4 +556,21 @@ function simplex.Seed(seed)
     end
 end
 
+-- TODO test functionality
+function simplex.FractalBrownianMotion2D(x, y, octaves, lacunarity, gain)
+    octaves = octaves or 4
+    lacunarity = lacunarity or 2
+    gain = gain or 0.5
+
+    local total, amplitude, frequency, peak_amplitude = 0, 1, 1, 0
+    for i = 1, octaves do
+        total = total + amplitude * simplex.Noise2D(x * frequency, y * frequency)
+        peak_amplitude = peak_amplitude + amplitude
+        amplitude = amplitude * gain
+        frequency = frequency * lacunarity
+    end
+
+    return total / peak_amplitude   -- normalize to [-1, 1]
+end
+
 return simplex

src/lib/simplex_map.lua

@@ -0,0 +1,77 @@
+local simplex = require "lib.simplex"
+
+local simplex_map = {}
+
+simplex_map.min = function(map)
+  local r = math.huge
+  for i=1,#map do
+    if map[i] then
+      for j=1,#map[1] do
+        local v = map[i][j]
+        if v and r > v then r = v end
+      end
+    end
+  end
+  return r
+end
+simplex_map.max = function(map)
+  local r = -math.huge
+  for i=1,#map do
+    if map[i] then
+      for j=1,#map[1] do
+        local v = map[i][j]
+        if v and r < v then r = v end
+      end
+    end
+  end
+  return r
+end
+
+simplex_map.normalize = function(map, new_min, new_max)
+  local minimum = simplex_map.min(map)
+  local initialRange = simplex_map.max(map) - minimum
+  local finalRange = new_max - new_min
+  for i = 1, #map do
+    for j = 1, #map[1] do
+      map[i][j] = (map[i][j] - minimum) / initialRange * finalRange + new_min
+    end
+  end
+  map.min = simplex_map.min(map)
+  map.max = simplex_map.max(map)
+  return map -- superfluous
+end
+
+simplex_map.generate = function(size, scale, min, max, octaves, lacunarity, gain)
+  if type(size) == "table" then
+    scale = size.scale
+    min = size.min
+    max = size.max
+    octaves = size.octaves
+    lacunarity = size.lacunarity
+    gain = size.gain
+
+    size = size.size
+  end
+
+  simplex.Seed(math.random())
+  local map = {}
+  map.size = size
+
+  scale = scale or 0.005
+  for x = 1, map.size do
+    map[x] = {}
+    for y = 1, map.size do
+      map[x][y] = simplex.FractalBrownianMotion2D(x * scale, y * scale, octaves, lacunarity, gain)
+    end
+  end
+
+  if min or max then
+    min = min or 0
+    max = max or 1
+    simplex_map.normalize(map, min, max)
+  end
+
+  return map
+end
+
+return simplex_map

src/main.lua

@@ -1,11 +1,19 @@
+math.randomseed(os.time())
+
 local map_generator = require "map_nextgen"
 local lovebird = require "lib.lovebird"
 local lume = require "lib.lume"
+local running_average = require "lib.running_average"
+local simplex_map = require "lib.simplex_map"
 
 local map
 
 love.load = function()
   map = map_generator.generate()
+  map.temperature.min = simplex_map.min(map.temperature)
+  map.temperature.max = simplex_map.max(map.temperature)
+  print("Min Temperature", map.temperature.min, "Average", running_average.track("minT", map.temperature.min))
+  print("Max Temperature", map.temperature.max, "Average", running_average.track("maxT", map.temperature.max))
 
   -- if true then return end
 
@@ -66,10 +74,11 @@ love.draw = function()
 
   for x = 1, map.size do
     for y = 1, map.size do
-      -- print(x, y) -- TEMP why am I getting an out of bounds?
+      -- local value = map.biome[x][y]
-      local value = map.biome[x][y]
+      local value = map.temperature[x][y]
       if value then
-        love.graphics.setColor(value)
+        -- love.graphics.setColor(value)
+        love.graphics.setColor( (value + map.temperature.max) / (map.temperature.max + math.abs(map.temperature.min)) , 0, 0, 1)
         love.graphics.rectangle("fill", x * map.tile_size, y * map.tile_size, map.tile_size, map.tile_size)
       end
     end
@@ -81,5 +90,9 @@ love.keypressed = function(key)
     love.event.quit()
   elseif key == "r" then
     love.load()
+  elseif key == "=" then
+    map.tile_size = map.tile_size * 2
+  elseif key == "-" then
+    map.tile_size = map.tile_size / 2
   end
 end

src/map_nextgen.lua

@@ -1,71 +1,7 @@
 -- NOTE the API of this file should probably change?
 
 local lume = require "lib.lume"
-local simplex = require "lib.simplex"
+local simplex_map = require "lib.simplex_map"
-
-local simplex_map = {}
-
-simplex_map.min = function(map)
-  local r = map[1][1]
-  for i=1,#map do
-    for j=1,#map[1] do
-      if r > map[i][j] then r = map[i][j] end
-    end
-  end
-  return r
-end
-simplex_map.max = function(map)
-  local r = map[1][1]
-  for i=1,#map do
-    for j=1,#map[1] do
-      if r < map[i][j] then r = map[i][j] end
-    end
-  end
-  return r
-end
-
-simplex_map.normalize = function(map, new_min, new_max)
-  local minimum = simplex_map.min(map)
-  local initialRange = simplex_map.max(map) - minimum
-  local finalRange = new_max - new_min
-  for i = 1, #map do
-    for j = 1, #map[1] do
-      map[i][j] = (map[i][j] - minimum) / initialRange * finalRange + new_min
-    end
-  end
-  map.min = simplex_map.min(map)
-  map.max = simplex_map.max(map)
-  return map -- superfluous
-end
-
-simplex_map.generate = function(size, scale, min, max)
-  if type(size) == "table" then
-    scale = size.scale
-    min = size.min
-    max = size.max
-    size = size.size
-  end
-
-  simplex.Seed(math.random())
-  local map = {}
-  map.size = size
-
-  scale = scale or 0.005
-  for x = 1, map.size do
-    map[x] = {}
-    for y = 1, map.size do
-      map[x][y] = simplex.Noise2D(x * scale, y * scale)
-    end
-  end
-
-  if min or max then
-    min = min or 0
-    max = max or 1
-    simplex_map.normalize(map, min, max)
-  end
-
-  return map
-end
 
 local biomes = {
   -- biomes are checked in order, with the first candidate always being selected
@@ -117,9 +53,19 @@ local generate = function()
   local map = {}
   map.size = 500
   map.tile_size = 1 -- TODO tile_size really shouldn't be the responsibility of the map generator - it's a rendering detail, not a map feature
-  map.altitude = simplex_map.generate(map.size, 0.005, 0, 1) -- meters
+  map.altitude = simplex_map.generate{   -- will be converted to meters
-  map.temperature = simplex_map.generate(map.size, 0.005, -89.2, 56.7) -- celsius
+    size = map.size, scale = 0.001, min = 0, max = 1,
-  map.rainfall = simplex_map.generate(map.size, 0.005, 18, 3240) -- millimeters rainfall
+    octaves = 7, lacunarity = 2, gain = 0.5,
+  }
+  map.temperature = simplex_map.generate{   -- in celsius
+    -- -20 to 45 chosen by looking at the temperature range shown on https://openclimatemap.org/
+    size = map.size, scale = 0.005, min = -20, max = 45, -- approximate target extremes of -89.2 to 56.7
+    octaves = 1, lacunarity = 2, gain = 0.5,
+  }
+  map.rainfall = simplex_map.generate{   -- in millimeters of rainfall
+    size = map.size, scale = 0.005, -- min = 18, max = 3240,
+    octaves = 1, lacunarity = 2, gain = 0.5,
+  }
 
   local function earthlike_altitude_adjustment(altitude)
     -- TODO replace with a simpler function?
@@ -146,13 +92,28 @@ local generate = function()
     map.biome[x] = {}
     for y = 1, map.size do
       if lume.distance(x, y, map.size / 2, map.size / 2, true) < radius_squared then
+        local altitude = map.altitude[x][y]
+        local temperature = map.temperature[x][y]
+        local rainfall = map.rainfall[x][y]
+
+        -- modify temperature based on altitude
+        if altitude > 0 then
+          temperature = temperature - 0.0065 * altitude  -- -6.5 C / km
+        else
+          temperature = temperature + altitude / 1000 -- -1 C / km (deep water adjustment)
+        end
+        -- modify temperature by latitude
+        local polar_distance = math.abs(y - (map.size / 2))^1.1 -- experimenting with slight non-linearity
+        local max_temperature_delta = 40
+        temperature = temperature - (polar_distance / map.size * 2 * max_temperature_delta)
+        -- 'save' temperature changes
+        map.temperature[x][y] = temperature
+
+        -- choose biome
         for _, order in ipairs(biome_order) do
           local biome = biomes[order]
-          local altitude = map.altitude[x][y]
           if altitude >= biome.altitude.min and altitude <= biome.altitude.max then
-            local temperature = map.temperature[x][y]
             if temperature >= biome.temperature.min and temperature <= biome.temperature.max then
-              local rainfall = map.rainfall[x][y]
               if rainfall >= biome.rainfall.min and rainfall <= biome.rainfall.max then
                 map.biome[x][y] = biome.color
                 break
@@ -160,6 +121,11 @@ local generate = function()
             end
           end
         end
+      else
+        -- clear non-planet zones
+        map.altitude[x][y] = nil
+        map.temperature[x][y] = nil
+        map.rainfall[x][y] = nil
       end
     end
   end