Update ReadMe.md

ReadMe.md

@@ -4,18 +4,26 @@ Eventually, it's supposed to be a survival/crafting game with space travel. Henc
 Using the heightmap generator from here: https://github.com/TangentFoxy/heightmap
 
 ## Tasks
-- [ ] Make a GitHub mirror for this repo.
+- [x] Make a GitHub mirror for this repo.
 - [ ] 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/final_map.lua

@@ -0,0 +1,166 @@
+local lume = require "lib.lume"
+local simplex_map = require "lib.simplex_map"
+
+local biomes_list = {
+  -- checked in order, first candidate always selected
+  [800] = {
+    name = "sea ice",
+    altitude = {min = -math.huge, max = 0.1},
+    temperature = {min = -math.huge, max = -1.8},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.6, 0.6, 1, 1},
+  },
+  [900] = {
+    name = "deep ocean",
+    altitude = {min = -math.huge, max = -0.09},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0, 0, 0.25, 1},
+  },
+  [950] = {
+    name = "shallow ocean",
+    altitude = {min = 0.05, max = 0.1},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.1, 0.1, 0.6, 1},
+  },
+  -- [2050] = { -- this was too inappropriately placed every time
+  --   name = "fresh water lake", -- NOTE experimental
+  --   altitude = {min = 0.1, max = math.huge},
+  --   temperature = {min = -math.huge, max = math.huge},
+  --   rainfall = {min = 0.9, max = math.huge},
+  --   color = {1, 0, 0, 1}, -- TEMP red to stand out, should be 0.1, 0.1, 1, 1
+  -- },
+  [1000] = {
+    name = "ocean",
+    altitude = {min = -math.huge, max = 0.1},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0, 0, 0.5, 1},
+  },
+  [1010] = {
+    name = "sandy beach",
+    altitude = {min = 0.1, max = 0.12},
+    temperature = {min = -1.4, max = math.huge},
+    rainfall = {min = -0.5, max = math.huge},
+    color = {1, 1, 0.33, 1},
+  },
+  [1500] = {
+    name = "frozen", -- NOTE probably temporary? (will be overwritten by higher priority subdivisions)
+    altitude = {min = -math.huge, max = math.huge},
+    temperature = {min = -math.huge, max = -1.85},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {1, 1, 1, 1},
+  },
+  [2000] = {
+    name = "snowline",
+    altitude = {min = 0.515, max = math.huge},
+    temperature = {min = -math.huge, max = -1.85},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {1, 1, 1, 1},
+  },
+  [2100] = {
+    name = "alpine zone",
+    altitude = {min = 0.52, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.8, 0.8, 0.8, 1},
+  },
+  [2200] = {
+    name = "subalpine zone",
+    altitude = {min = 0.48, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.67, 0.67, 0.67, 1},
+  },
+  [2300] = {
+    name = "montane zone",
+    altitude = {min = 0.4, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.67, 0.67, 0.5, 1},
+  },
+  [9999] = {
+    name = "template",
+    altitude = {min = -math.huge, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0, 0, 0, 1},
+  },
+}
+
+local generate = function()
+  local map = {}
+  map.size = 500
+  map.tile_size = 1 -- TODO should be in rendering, not map, the map doesn't care about tile_size
+  map.altitude = simplex_map.generate{
+    size = map.size, scale = 0.004, -- min = 0, max = 1, -- TEMP min/max range set to representable values
+    octaves = 5, lacunarity = 2.01, gain = 0.51,
+  }
+  map.temperature = simplex_map.generate{
+    size = map.size, scale = 0.005, -- min = 0, max = 1, -- TEMP range adjusted for easy representation
+    octaves = 3, lacunarity = 1.99, gain = 0.49,
+  }
+  map.rainfall = simplex_map.generate{
+    size = map.size, scale = 0.006, -- min = 0, max = 1, -- TEMP easy representation range
+    octaves = 1,
+  }
+
+  local biome_order = {}
+  for order in pairs(biomes_list) do
+    biome_order[#biome_order + 1] = order
+  end
+  table.sort(biome_order)
+
+  local map_center, radius_squared = map.size / 2, (map.size / 2)^2
+  map.biome = {}
+  for x = 1, map.size do
+    map.biome[x] = {}
+    for y = 1, map.size do
+      if lume.distance(x, y, map_center, map_center, 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
+        temperature = temperature - 2 * altitude
+
+        -- modify temperature based on latitude
+        local polar_distance = math.abs(y - map_center)^1.5
+        local max_temperature_delta = 0.2
+        temperature = temperature - (polar_distance / map.size * 2 * max_temperature_delta)
+        map.temperature[x][y] = temperature
+
+        -- choose biome
+        for _, order in ipairs(biome_order) do
+          local biome = biomes_list[order]
+          if altitude >= biome.altitude.min and altitude <= biome.altitude.max then
+            if temperature >= biome.temperature.min and temperature <= biome.temperature.max then
+              if rainfall >= biome.rainfall.min and rainfall <= biome.rainfall.max then
+                map.biome[x][y] = biome.color
+                -- map.biome[x][y] = {rainfall, rainfall, rainfall, 1} -- TEMP what does the map actually look like?
+                break
+              end
+            end
+          end
+        end
+      else
+        -- clear non-planet area
+        -- NOTE this potentially leaves behind empty x tables
+        map.altitude[x][y] = nil
+        map.temperature[x][y] = nil
+        map.rainfall[x][y] = nil
+      end
+    end
+  end
+
+  simplex_map.recalculate_range(map.altitude)
+  simplex_map.recalculate_range(map.temperature)
+  simplex_map.recalculate_range(map.rainfall)
+
+  return map
+end
+
+return {
+  generate = generate,
+}

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,81 @@
+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.recalculate_range = function(map)
+  map.min = simplex_map.min(map)
+  map.max = simplex_map.max(map)
+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
+  simplex_map.recalculate_range(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,17 @@
-local map_generator = require "map_nextgen"
+math.randomseed(os.time())
+
+local map_generator = require "final_map"
 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()
+  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 +72,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.terrain[x][y]
+      -- local value = map.temperature[x][y]
       if value then
         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 +88,11 @@ love.keypressed = function(key)
     love.event.quit()
   elseif key == "r" then
     love.load()
+  elseif key == "t" then
+    print(running_average.count("minT"))
+  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,73 +1,149 @@
 -- NOTE the API of this file should probably change?
 
-local simplex = require "lib.simplex"
+local lume = require "lib.lume"
+local simplex_map = require "lib.simplex_map"
+
+local biomes = {
+  -- biomes are checked in order, with the first candidate always being selected
+  [800] = {
+    name = "sea ice",
+    altitude = {min = -math.huge, max = 0},
+    temperature = {min = -math.huge, max = -2},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.6, 0.6, 1, 1},
+  },
+  [900] = {
+    name = "deep ocean",
+    altitude = {min = -math.huge, max = -5000},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0, 0, 0.25, 1},
+  },
+  [1000] = {
+    name = "ocean (definition, 0 meters)",
+    altitude = {min = -math.huge, max = 0},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0, 0, 0.5, 1},
+  },
+  [1500] = {
+    name = "frozen (definition, 0 C)",
+    altitude = {min = -math.huge, max = math.huge},
+    temperature = {min = -math.huge, max = 0},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {1, 1, 1, 1},
+  },
+  [2000] = {
+    name = "snowline (middle estimate)",
+    altitude = {min = 4000, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {1, 1, 1, 1},
+  },
+  [2100] = {
+    name = "alpine zone",
+    altitude = {min = 3500, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.8, 0.8, 0.8, 1},
+  },
+  [2200] = {
+    name = "subalpine zone",
+    altitude = {min = 3000, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.67, 0.67, 0.67, 1},
+  },
+  [2300] = {
+    name = "montane zone",
+    altitude = {min = 2500, max = math.huge},
+    temperature = {min = -math.huge, max = math.huge},
+    rainfall = {min = -math.huge, max = math.huge},
+    color = {0.67, 0.67, 0.5, 1},
+  },
+}
 
 local generate = function()
-  simplex.Seed(math.random())
-
   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 = {} -- TEMP only one noise map
+  map.altitude = simplex_map.generate{   -- will be converted to meters
+    size = map.size, scale = 0.001, min = 0, max = 1,
+    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 = 65, -- approximate target extremes of -89.2 to 56.7
+    octaves = 2, 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?
+    return 6099 - 114909 * altitude + 830891 * altitude^2 - 2.72e6 * altitude^3 + 4.19e6 * altitude^4 - 3.02e6 * altitude^5 + 815866 * altitude^6
+  end
 
-  local scale = 0.005
-  local min, max = math.huge, -math.huge
   for x = 1, map.size do
-    map.altitude[x] = {}
     for y = 1, map.size do
-      local value = simplex.Noise2D(x * scale, y * scale)
+      map.altitude[x][y] = earthlike_altitude_adjustment(map.altitude[x][y])
-      if value > max then max = value end
-      if value < min then min = value end
-      map.altitude[x][y] = value
     end
   end
-  print("Altitude", "Min:", min, "Max:", max)
+  map.altitude.min = simplex_map.min(map.altitude)
+  map.altitude.max = simplex_map.max(map.altitude)
 
-  -- TEMP hacked in copy to fix the issue so I can make sure everything is correct aaa
+  local biome_order = {}
-  local function min(t)
+  for order in pairs(biomes) do
-    local r = t[1][1]
+    biome_order[#biome_order + 1] = order
-    for i=1,#t do
-      for j=1,#t[1] do
-        if r > t[i][j] then r = t[i][j] end
-      end
-    end
-    return r
   end
-  local function max(t)
+  table.sort(biome_order)
-    local r = t[1][1]
-    for i=1,#t do
-      for j=1,#t[1] do
-        if r < t[i][j] then r = t[i][j] end
-      end
-    end
-    return r
-  end
-  local function normalize(map, new_min, new_max)
-    local minimum = min(map)
-    local initialRange = 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 = min(map)
-    map.max = max(map)
-    return map -- superfluous
-  end
-  normalize(map.altitude, 0, 1)
 
-  map.terrain = {}
+  local radius_squared = (map.size / 2)^2
+  map.biome = {}
   for x = 1, map.size do
-    map.terrain[x] = {}
+    map.biome[x] = {}
     for y = 1, map.size do
-      local value = map.altitude[x][y]
+      if lume.distance(x, y, map.size / 2, map.size / 2, true) < radius_squared then
-      map.terrain[x][y] = {value, value, value, 1}
+        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.3 -- experimenting with slight non-linearity
+        local max_temperature_delta = 10
+        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]
+          if altitude >= biome.altitude.min and altitude <= biome.altitude.max then
+            if temperature >= biome.temperature.min and temperature <= biome.temperature.max then
+              if rainfall >= biome.rainfall.min and rainfall <= biome.rainfall.max then
+                map.biome[x][y] = biome.color
+                break
+              end
+            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
 
-  -- NOTE this is missing the radius modifier, so it's a square map
-
   return map
 end