ruby-perlin-2D-map-generator 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a4341c2583eba83e95d6ea4a9c1ee05a857bc1f5c77c6d3aeeba41f6995a656
-  data.tar.gz: 599b47f78c83dc6acd99dcde0e9aadbeb8d445fc7d9b6ef7ba8b1acbb3c15d7b
+  metadata.gz: 8bef2e8554e39c0e315b940f4a98a8927348ae576a7f12168c86c74f969c241b
+  data.tar.gz: b3debfe8269979c1f1f0be2a8def6a86de9fcd2a8ad6f548295113068ec04566
 SHA512:
-  metadata.gz: bbabe795544e432d7cf4e5dac2fd6f2b14dd17239d3eb2a59013ce3655bcee1873ef4edb5e6048be372c474af04234e5f7ef33806b517de1b160ea5d59b3d62f
-  data.tar.gz: 246cc08e1413e89c6929eacf4201a7895e64595067367f02ed8e758a239e18b098186e16c1c8a85900e1519fa84eb5ace115d15e094894b62825664b1059e57d
+  metadata.gz: c91f9810eda61b360e26b31944820b2587ff9e6a10776cdc84347475470573b381853e63b629781fbc0f18eb9fc33299fad31e2a436ef7f7a66d67db8dbb2ea2
+  data.tar.gz: 8c12388e0e7965165557bc5680f030d6d2da9a42e35cc066fbff2390de0e6076c2318e7d62000d17026fa91206adb1ff631eff0ff6af5d670ef81e3d206e45a0

data/README.md

@@ -3,16 +3,18 @@
 [![Gem Version](https://badge.fury.io/rb/ruby-perlin-2D-map-generator.svg)](https://badge.fury.io/rb/ruby-perlin-2D-map-generator)
 ![CI Status](https://github.com/matthewstyler/ruby-perlin-2D-map-generator/actions/workflows/main.yml/badge.svg)
 ![CodeQL](https://github.com/matthewstyler/ruby-perlin-2D-map-generator/workflows/CodeQL/badge.svg)
+<a href="https://codeclimate.com/github/matthewstyler/ruby-perlin-2D-map-generator/test_coverage"><img src="https://api.codeclimate.com/v1/badges/b99aae29d02b7a8a4cc6/test_coverage" /></a>
+<a href="https://codeclimate.com/github/matthewstyler/ruby-perlin-2D-map-generator/maintainability"><img src="https://api.codeclimate.com/v1/badges/b99aae29d02b7a8a4cc6/maintainability" /></a>
 [![Downloads](https://img.shields.io/gem/dt/ruby-perlin-2D-map-generator.svg?style=flat)](https://rubygems.org/gems/ruby-perlin-2D-map-generator)
 
-A gem that procedurally generates seeded and customizable 2D map with optional roads using perlin noise.
+A gem that procedurally generates seeded and customizable 2D map with optional roads and towns using perlin noise.
 
 Include the gem in your project, or use the executable from the command line.
 
 Map can be rendered in console using ansi colors or returned as 2D array of hashes describing each tile and binome. Completely customizable, use the --help option for full usage details.
 
 
-![2D-maps](https://github.com/matthewstyler/ruby-perlin-2D-map-generator/assets/4560901/4fa5883f-839a-40c9-86a1-d5f9e2c37b9a)
+![2D-maps](https://github.com/matthewstyler/ruby-perlin-2D-map-generator/assets/4560901/6234ebc1-f3bd-48b5-9b78-4d286d2c8d6e)
 
 
 # Installation
@@ -48,7 +50,8 @@ See Command line Usage for full customization, below are some examples. Alter th
 --roads=int        Add this many roads through the map,
                      starting and ending at edges 
                          (default 0)
-
+--towns=int        Add this randomly sized towns
+                         (default 0)
 --hs=int           The seed for a terrains height perlin generation
                          (default 10)
 --ms=int           The seed for a terrains moist perlin generation
@@ -70,7 +73,7 @@ See Command line Usage for full customization, below are some examples. Alter th
 Roads can be generated by providing a positive integer to the `roads=` argument. Roads are randomly seeded to begin
 and start at an axis (but not the same axis).
 
-A* pathfinding is used to generate the roads with a heuristic that uses manhattan distance, favours existing roads and similar elevations in adjacent tiles. 
+A* pathfinding with a priority queue is used to generate the roads. The heuristic uses manhattan distance, and favours existing roads and similar elevations in adjacent tiles. 
 
 Roads can be configured to include/exclude generating paths thorugh water, mountains and flora.
 
@@ -78,6 +81,8 @@ Tiles containing roads are of type `road`, those without are of type `terrain`.
 
 The `--roads_to_make` option allows you to specify multiple pairs of coordinates to attempt to build paths, subject to the heuristic and other option constraints. Expects a a single list, but must be sets of 4, example of two roads: `--roads_to_make=0,0,50,50,0,0,75,75`
 
+## Towns
+With Poisson Disk Sampling, towns can be generated randomly or with a provided x,y coordinate used as a centroid with radius. The result will be tiles that contain `Building` `items`. Buildings in a town are connected by roads, and additionally towns are connected to other towns by roads.
 # Generate without rendering
 
 ```irb
@@ -201,6 +206,16 @@ Options:
                                          (default 100)
       --temp=float                       Adjust each generated temperature by
                                          this percent (-100 - 100) (default 0.0)
+      --town_seed=int                    The seed for generating towns
+                                         (default 500)
+      --towns=int                        Add this many randomly sized towns
+                                         throughout the map 
+                                         (default 0)
+      --towns_to_make ints               Attempt to create a town at given x,y
+                                         coordinate, with z points and v radius
+                                         (4 integers). Can be supplied multiple
+                                         towns. 
+                                         (default [])
       --ts=int                           The seed for a terrains temperature
                                          perlin generation (default 3000)
       --width=int                        The width of the generated map
@@ -215,6 +230,9 @@ Examples:
   
   Render with roads
     $ ruby-perlin-2D-map-generator render --roads=2
+  
+  Render with 5 roads, 1 provided road, 10 random towns and 1 provided town
+    $ ruby-perlin-2D-map-generator render --roads=5 --roads_to_make=0,0,50,50 --towns=10 --towns_to_make=5,5,10,3
 
   Describe tile [1, 1]
     $ ruby-perlin-2D-map-generator describe coordinates=1,1

data/lib/CLI/command.rb

@@ -53,6 +53,15 @@ module CLI
       default MapConfig::DEFAULT_ROADS_TO_MAKE
     end
 
+    option :towns_to_make do
+      arity one
+      long '--towns_to_make ints'
+      convert :int_list
+      validate ->(v) { v >= 0 }
+      desc 'Attempt to create a town at given x,y coordinate, with z points and v radius (4 integers). Can be supplied multiple towns.'
+      default MapConfig::DEFAULT_TOWNS_TO_MAKE
+    end
+
     option :height_seed do
       long '--hs int'
       # or
@@ -294,6 +303,31 @@ module CLI
       default MapConfig::DEFAULT_ROAD_EXCLUDE_FLORA_PATH
     end
 
+    option :town_seed do
+      long '--town_seed int'
+      long '--town_seed=int'
+
+      desc 'The seed for generating towns'
+      convert Integer
+      default MapConfig::DEFAULT_TOWN_SEED
+    end
+
+    option :towns do
+      long '--towns int'
+      long '--towns=int'
+
+      desc 'Add this many randomly sized towns throughout the map'
+      convert Integer
+      validate ->(val) { val >= 0 }
+      default MapConfig::DEFAULT_NUM_OF_TOWNS
+    end
+
+    option :verbose do
+      arity one
+      long '--verbose'
+      desc 'Used with the render command, outputs loading information'
+    end
+
     flag :help do
       short '-h'
       long '--help'
@@ -319,7 +353,9 @@ module CLI
         height: params[:height],
         all_perlin_configs: MapConfig::AllPerlinConfigs.new(perlin_height_config, perlin_moist_config, perlin_temp_config),
         generate_flora: params[:generate_flora],
-        road_config: MapConfig::RoadConfig.new(*params.to_h.slice(:road_seed, :roads, :road_exclude_water_path, :road_exclude_mountain_path, :road_exclude_flora_path, :roads_to_make).values)
+        road_config: MapConfig::RoadConfig.new(*params.to_h.slice(:road_seed, :roads, :road_exclude_water_path, :road_exclude_mountain_path, :road_exclude_flora_path, :roads_to_make).values),
+        town_config: MapConfig::TownConfig.new(*params.to_h.slice(:town_seed, :towns, :towns_to_make).values),
+        verbose: params[:verbose]
       ))
       case params[:command]
       when 'render' then map.render

data/lib/biome.rb

@@ -151,21 +151,21 @@ class Biome
       case elevation
       when 0.95..1
         SNOW
-      when 0.9..0.95
+      when 0.9...0.95
         ROCKS
-      when 0.8..0.9
+      when 0.8...0.9
         if moist < 0.9
           MOUNTAIN
         else
           SHOAL
         end
-      when 0.7..0.8
+      when 0.7...0.8
         if moist < 0.9
           MOUNTAIN_FOOT
         else
           SHOAL
         end
-      when 0.6..0.7
+      when 0.6...0.7
         if moist < 0.8
           if desert_condition?(moist, temp)
             STEPPE_DESERT
@@ -179,7 +179,7 @@ class Biome
         else
           SHOAL
         end
-      when 0.3..0.6
+      when 0.3...0.6
         if desert_condition?(moist, temp)
           DESERT
         elsif taiga_condition?(moist, temp)
@@ -187,7 +187,7 @@ class Biome
         else
           VALLEY
         end
-      when 0.2..0.3
+      when 0.2...0.3
         if desert_condition?(moist, temp)
           DEEP_DESERT
         elsif taiga_condition?(moist, temp)
@@ -195,25 +195,25 @@ class Biome
         else
           DEEP_VALLEY
         end
-      when 0.15..0.2
+      when 0.15...0.2
         if taiga_condition?(moist, temp)
           TAIGA_COAST
         else
           COASTLINE
         end
-      when 0.05..0.15
+      when 0.05...0.15
         if taiga_condition?(moist, temp)
           ICE
         else
           SHOAL
         end
-      when 0.025..0.05
+      when 0.025...0.05
         if taiga_condition?(moist, temp)
           ICE
         else
           OCEAN
         end
-      when 0.0..0.025
+      when 0.0...0.025
         if taiga_condition?(moist, temp)
           ICE
         else

data/lib/building.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'tile_item'
+
+#
+# Represents a building item on a tile
+#
+class Building < TileItem
+  TOWN_RENDER_PRIORITY = DEFAULT_RENDER_PRIORITY + 1
+
+  HOUSE = "\u{1F3E0}"
+
+  def initialize(render_symbol)
+    super self, render_symbol: render_symbol, render_priority: TOWN_RENDER_PRIORITY
+  end
+
+  def self.random_town_building(_seed)
+    Building.new(HOUSE)
+  end
+end

data/lib/flora_generator.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+#
+# Generates flora for the given tiles
+#
+class FloraGenerator
+  attr_reader :tiles
+
+  def initialize(tiles)
+    @tiles = tiles
+  end
+
+  def generate(config)
+    return unless config.generate_flora
+
+    puts 'generating flora...' if config.verbose
+    tiles.each do |row|
+      row.each do |tile|
+        next unless tile.biome.flora_available
+
+        range_max_value = tiles[(tile.y - tile.biome.flora_range)...(tile.y + tile.biome.flora_range)]&.map do |r|
+          r[(tile.x - tile.biome.flora_range)...(tile.x + tile.biome.flora_range)]
+        end&.flatten&.map(&:height)&.max
+        tile.add_flora if range_max_value == tile.height
+      end
+    end
+  end
+end

data/lib/map.rb

@@ -3,6 +3,8 @@
 require 'map_tile_generator'
 require 'map_config'
 require 'road_generator'
+require 'town_generator'
+require 'flora_generator'
 
 class Map
   attr_reader :config
@@ -33,16 +35,33 @@ class Map
   def tiles
     return @tiles if @tiles
 
-    @tiles = generate_tiles
-    road_generator = RoadGenerator.new(@tiles)
-    road_generator.generate_num_of_random_roads(config.road_config)
-    road_generator.generate_roads_from_coordinate_list(config.road_config.roads_to_make)
+    generate_tiles
+    generate_flora
+    generate_roads
+    generate_towns
+
     @tiles
   end
 
   private
 
   def generate_tiles
-    MapTileGenerator.new(map: self).generate
+    @tiles = MapTileGenerator.new(map: self).generate
+  end
+
+  def generate_flora
+    FloraGenerator.new(@tiles).generate(config)
+  end
+
+  def generate_roads
+    road_generator = RoadGenerator.new(@tiles)
+    road_generator.generate_num_of_random_roads(config.road_config)
+    road_generator.generate_roads_from_coordinate_list(config.road_config.roads_to_make, config.verbose)
+  end
+
+  def generate_towns
+    town_generator = TownGenerator.new(@tiles, seed: config.town_config.town_seed)
+    town_generator.generate_random_towns(config.town_config)
+    town_generator.generate_towns_from_coordinate_list(config.town_config)
   end
 end

data/lib/map_config.rb

@@ -32,18 +32,27 @@ class MapConfig
   DEFAULT_ROAD_EXCLUDE_FLORA_PATH    = true
   DEFAULT_ROADS_TO_MAKE              = [].freeze
 
+  DEFAULT_TOWN_SEED                  = 500
+  DEFAULT_NUM_OF_TOWNS               = 0
+  DEFAULT_TOWNS_TO_MAKE              = [].freeze
+
+  DEFAULT_VERBOSE                    = false
+
   PERLIN_CONFIG_OPTIONS = %i[width height noise_seed octaves x_frequency y_frequency persistance adjustment].freeze
   ALL_PERLIN_CONFIGS    = %i[perlin_height_config perlin_moist_config perlin_temp_config].freeze
-  ROAD_CONFIG_OPTIONS   = %i[road_seed roads road_exclude_water_path road_exclude_mountain_path road_exclude_flora_path roads_to_make].freeze
+  ROAD_CONFIG_OPTIONS   = %i[road_seed roads road_exclude_water_path road_exclude_mountain_path road_exclude_flora_path roads_to_make verbose].freeze
+  TOWN_CONFIG_OPTIONS   = %i[town_seed towns towns_to_make verbose].freeze
 
   PerlinConfig = Struct.new(*PERLIN_CONFIG_OPTIONS)
   AllPerlinConfigs = Struct.new(*ALL_PERLIN_CONFIGS)
   RoadConfig = Struct.new(*ROAD_CONFIG_OPTIONS)
+  TownConfig = Struct.new(*TOWN_CONFIG_OPTIONS)
 
-  attr_reader :generate_flora, :perlin_height_config, :perlin_moist_config, :perlin_temp_config, :width, :height, :road_config
+  attr_reader :generate_flora, :perlin_height_config, :perlin_moist_config, :perlin_temp_config, :width, :height, :road_config, :town_config, :verbose
 
+  # rubocop:disable Metrics/ParameterLists:
   def initialize(all_perlin_configs: default_perlin_configs, width: DEFAULT_TILE_COUNT,
-                 height: DEFAULT_TILE_COUNT, generate_flora: DEFAULT_GENERATE_FLORA, road_config: default_road_config)
+                 height: DEFAULT_TILE_COUNT, generate_flora: DEFAULT_GENERATE_FLORA, road_config: default_road_config, town_config: default_town_config, verbose: DEFAULT_VERBOSE)
     validate(all_perlin_configs)
     @generate_flora = generate_flora
     @perlin_height_config = all_perlin_configs.perlin_height_config
@@ -52,7 +61,12 @@ class MapConfig
     @width = width
     @height = height
     @road_config = road_config
+    @town_config = town_config
+    @verbose = verbose
+    town_config.verbose = verbose
+    road_config.verbose = verbose
   end
+  # rubocop:enable Metrics/ParameterLists:
 
   private
 
@@ -78,7 +92,12 @@ class MapConfig
   end
 
   def default_road_config
-    RoadConfig.new(DEFAULT_ROAD_SEED, DEFAULT_NUM_OF_ROADS, DEFAULT_ROAD_EXCLUDE_WATER_PATH, DEFAULT_ROAD_EXCLUDE_MOUNTAIN_PATH, DEFAULT_ROAD_EXCLUDE_FLORA_PATH, DEFAULT_ROADS_TO_MAKE)
+    RoadConfig.new(DEFAULT_ROAD_SEED, DEFAULT_NUM_OF_ROADS, DEFAULT_ROAD_EXCLUDE_WATER_PATH, DEFAULT_ROAD_EXCLUDE_MOUNTAIN_PATH, DEFAULT_ROAD_EXCLUDE_FLORA_PATH, DEFAULT_ROADS_TO_MAKE,
+                   DEFAULT_VERBOSE)
+  end
+
+  def default_town_config
+    TownConfig.new(DEFAULT_TOWN_SEED, DEFAULT_NUM_OF_TOWNS, DEFAULT_TOWNS_TO_MAKE, DEFAULT_VERBOSE)
   end
 
   def default_perlin_configs

data/lib/map_tile_generator.rb

@@ -15,6 +15,7 @@ class MapTileGenerator
   end
 
   def generate
+    puts "generating #{map_config.width} x #{map_config.height} tiles..." if map_config.verbose
     positive_quadrant_cartesian_plane
   end
 

data/lib/pathfinding/a_star_finder.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'set'
+require 'pathfinding/priority_queue'
+
 module Pathfinding
   #
   # An A* Pathfinder to build roads/paths between two coordinates containing
@@ -7,28 +10,35 @@ module Pathfinding
   #
   class AStarFinder
     def find_path(start_node, end_node, grid)
-      open_set = [start_node]
       came_from = {}
       g_score = { start_node => 0 }
-      f_score = { start_node => heuristic_cost_estimate(start_node, end_node) }
+      f_score = { start_node => manhattan_distance(start_node, end_node) }
+
+      open_set = Pathfinding::PriorityQueue.new
+      open_set.push(start_node, f_score[start_node])
 
+      closed_set = Set.new
       until open_set.empty?
-        current_node = open_set.min_by { |node| f_score[node] }
+        current = open_set.pop
+
+        # Early exit if the current node is in the closed set
+        next if closed_set.include?(current)
 
-        return reconstruct_path(came_from, current_node) if current_node == end_node
+        # Mark the current node as visited
+        closed_set.add(current)
 
-        open_set.delete(current_node)
+        return reconstruct_path(came_from, current) if current == end_node
 
-        grid.neighbors(current_node).each do |neighbor|
-          tentative_g_score = g_score[current_node] + 1
+        grid.neighbors(current).each do |neighbor|
+          tentative_g_score = g_score[current] + 1
 
-          next unless !g_score[neighbor] || tentative_g_score < g_score[neighbor]
+          next if closed_set.include?(neighbor) || (g_score[neighbor] && tentative_g_score >= g_score[neighbor])
 
-          came_from[neighbor] = current_node
+          came_from[neighbor] = current
           g_score[neighbor] = tentative_g_score
           f_score[neighbor] = g_score[neighbor] + heuristic_cost_estimate(neighbor, end_node)
 
-          open_set << neighbor unless open_set.include?(neighbor)
+          open_set.push(neighbor, f_score[neighbor])
         end
       end
 
@@ -39,10 +49,13 @@ module Pathfinding
     private
 
     def heuristic_cost_estimate(node, end_node)
-      (node.x - end_node.x).abs +
-        (node.y - end_node.y).abs +
+      manhattan_distance(node, end_node) +
         (node.path_heuristic - end_node.path_heuristic) + # elevation for natural roads
-        (node.road? ? 0 : 5) # share existing roads
+        (node.road? ? 0 : 1000) # share existing roads
+    end
+
+    def manhattan_distance(node, end_node)
+      (node.x - end_node.x).abs + (node.y - end_node.y).abs
     end
 
     def reconstruct_path(came_from, current_node)

data/lib/pathfinding/grid.rb

@@ -20,19 +20,19 @@ module Pathfinding
 
     def neighbors(node)
       neighbors = []
-      return neighbors unless node.can_contain_road?
+      return neighbors unless node.can_haz_road?
 
       x = node.x
       y = node.y
 
       node_lookup = node(x - 1, y) if x.positive?
-      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_road?
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_haz_road?
       node_lookup = node(x + 1, y) if x < @nodes[0].size - 1
-      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_road?
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_haz_road?
       node_lookup = node(x, y - 1) if y.positive?
-      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_road?
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_haz_road?
       node_lookup = node(x, y + 1) if y < @nodes.size - 1
-      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_road?
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_haz_road?
 
       neighbors
     end

data/lib/pathfinding/priority_queue.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Pathfinding
+  #
+  # A Priority Queue implementation for managing elements with associated priorities.
+  # Elements are stored and retrieved based on their priority values.
+  #
+  # This Priority Queue is implemented using a binary heap, which provides efficient
+  # insertion, extraction of the minimum element, and deletion operations.
+  #
+  class PriorityQueue
+    def initialize(&block)
+      @heap = []
+      @compare = block || proc { |a, b| @priority_hash[a] < @priority_hash[b] }
+      @priority_hash = {}
+    end
+
+    def push(item, priority)
+      @heap << item
+      @priority_hash[item] = priority
+      heapify_up(@heap.length - 1)
+    end
+
+    def pop
+      return nil if @heap.empty?
+
+      swap(0, @heap.length - 1)
+      popped = @heap.pop
+      heapify_down(0)
+      popped
+    end
+
+    def peek
+      @heap[0]
+    end
+
+    def empty?
+      @heap.empty?
+    end
+
+    private
+
+    def heapify_up(index)
+      parent_index = (index - 1) / 2
+
+      return unless index.positive? && @compare.call(@heap[index], @heap[parent_index])
+
+      swap(index, parent_index)
+      heapify_up(parent_index)
+    end
+
+    def heapify_down(index)
+      left_child_index = 2 * index + 1
+      right_child_index = 2 * index + 2
+      smallest = index
+
+      smallest = left_child_index if left_child_index < @heap.length && @compare.call(@heap[left_child_index], @heap[smallest])
+
+      smallest = right_child_index if right_child_index < @heap.length && @compare.call(@heap[right_child_index], @heap[smallest])
+
+      return unless smallest != index
+
+      swap(index, smallest)
+      heapify_down(smallest)
+    end
+
+    # rubocop:disable Naming/MethodParameterName:
+    def swap(i, j)
+      @heap[i], @heap[j] = @heap[j], @heap[i]
+    end
+    # rubocop:enable Naming/MethodParameterName:
+  end
+end

data/lib/poisson_disk_sampling/sample_area.rb

@@ -0,0 +1,43 @@
+# frozen_string_literal: true
+
+module PoissonDiskSampling
+  #
+  # Encapsulates area to be sampled by poisson disk sampling
+  #
+  class SampleArea
+    def initialize(grid:)
+      @grid = grid.dup
+      @points = Array.new(height) { Array.new(width) { false } }
+    end
+
+    def height
+      @grid.length
+    end
+
+    def width
+      @grid[0].length
+    end
+
+    # rubocop:disable Naming/MethodParameterName:
+    def set_sampled_point(x, y)
+      @points[y][x] = true
+    end
+
+    def [](x, y)
+      @grid[y][x]
+    end
+
+    def sampled_point?(x, y)
+      @points[y][x]
+    end
+
+    def point_within_bounds?(x, y)
+      y >= 0 && y < height && x >= 0 && x < width
+    end
+
+    def point_within_bounds_and_can_have_road?(x, y)
+      point_within_bounds?(x, y) && @grid[y][x].can_haz_road?
+    end
+    # rubocop:enable Naming/MethodParameterName:
+  end
+end

data/lib/poisson_disk_sampling/sampler.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'pry-byebug'
+module PoissonDiskSampling
+  #
+  # Generates X randomly distributed points within given 2D space
+  # using possion disk sampling
+  #
+  class Sampler
+    attr_reader :sample_area, :num_attempts, :seed
+
+    def initialize(sample_area:, num_attempts: 20, seed: rand)
+      @sample_area = sample_area
+      @num_attempts = num_attempts
+      @seed = seed
+    end
+
+    def generate_points(num_of_points, radius, intial_start_point = nil)
+      raise ArgumentError, "invalid start argument #{intial_start_point}" if !intial_start_point.nil? && !intial_start_point.is_a?(Array) && intial_start_point.length != 1
+
+      retreive_points_until_active_list_empty_or_num_points_reached(intial_start_point || generate_and_assign_initial_point, num_of_points, radius)
+    end
+
+    private
+
+    def retreive_points_until_active_list_empty_or_num_points_reached(active_list, num_of_points, radius)
+      points = []
+      retrieve_points(active_list, points, num_of_points, radius) until active_list.empty? || points.length == num_of_points
+      points
+    end
+
+    def retrieve_points(active_list, points, num_of_points, radius)
+      return if active_list.empty?
+
+      current_point, active_index = retreive_current_point(active_list)
+      found = false
+
+      num_attempts.times do
+        new_point = generate_random_point_around(current_point, radius)
+        next if new_point.nil?
+        next unless new_point.can_haz_town? && neighbours_empty?(new_point, radius)
+
+        sample_area.set_sampled_point(new_point.x, new_point.y)
+        active_list << new_point
+        points << new_point
+        return points if points.length == num_of_points
+
+        found = true
+        break
+      end
+
+      active_list.delete_at(active_index) unless found
+    end
+
+    def random_value_and_increment_seed(max)
+      val = Random.new(seed).rand(max)
+      @seed += 1
+      val
+    end
+
+    def retreive_current_point(active_list)
+      active_index = random_value_and_increment_seed(active_list.length)
+      current_point = active_list[active_index]
+      [current_point, active_index]
+    end
+
+    def neighbours_empty?(new_point, radius)
+      cell_empty = true
+      (-radius..radius).each do |dy|
+        (-radius..radius).each do |dx|
+          x = new_point.x + dx
+          y = new_point.y + dy
+          next unless sample_area.point_within_bounds?(x, y) && sample_area[x, y]
+
+          if sample_area.sampled_point?(x, y) && distance(new_point, sample_area[x, y]) < radius
+            cell_empty = false
+            break
+          end
+        end
+        break unless cell_empty
+      end
+    end
+
+    def generate_and_assign_initial_point
+      num_attempts.times do
+        initial_point_coords = [random_value_and_increment_seed(sample_area.width), random_value_and_increment_seed(sample_area.height)]
+
+        if sample_area[initial_point_coords[0], initial_point_coords[1]].can_haz_town?
+          sample_area.set_sampled_point(initial_point_coords[0], initial_point_coords[1])
+          return [sample_area[initial_point_coords[0], initial_point_coords[1]]]
+        end
+      end
+      []
+    end
+
+    def generate_random_point_around(point, radius)
+      distance = radius * (random_value_and_increment_seed(1.0) + 1)
+      angle = 2 * Math::PI * random_value_and_increment_seed(1.0)
+      generated = [point.y + distance * Math.cos(angle), point.x + distance * Math.sin(angle)].map(&:round)
+
+      sample_area.point_within_bounds?(generated[1], generated[0]) ? sample_area[generated[1], generated[0]] : nil
+    end
+
+    def distance(point1, point2)
+      Math.sqrt((point1.y - point2.y)**2 + (point1.x - point2.x)**2)
+    end
+  end
+end

data/lib/road_generator.rb

@@ -17,8 +17,11 @@ class RoadGenerator
   def generate_num_of_random_roads(config)
     return if config.roads <= 0
 
+    puts "generating #{config.roads} random roads..." if config.verbose
+
     seed = config.road_seed
     (1..config.roads).each do |n|
+      puts "generating road #{n}..." if config.verbose
       random_objects_at_edges = random_nodes_not_on_same_edge(seed + n) # add n otherwise each road is the same
       generate_path(
         random_objects_at_edges[0].x,
@@ -29,7 +32,11 @@ class RoadGenerator
     end
   end
 
-  def generate_roads_from_coordinate_list(road_paths)
+  def generate_roads_from_coordinate_list(road_paths, verbose)
+    return unless (road_paths.length % 4).zero?
+
+    puts "generating #{road_paths.length / 4} coordinate roads..." if verbose
+
     road_paths.each_slice(4) do |road_coordinates|
       generate_path(
         road_coordinates[0],

data/lib/tile.rb

@@ -4,6 +4,7 @@ require 'biome'
 require 'flora'
 require 'ansi_colours'
 require 'pry-byebug'
+require 'building'
 
 class Tile
   attr_reader :x, :y, :height, :moist, :temp, :map, :type
@@ -42,7 +43,7 @@ class Tile
   end
 
   def items
-    @items ||= items_generated_with_flora_if_applicable
+    @items ||= []
   end
 
   def render_to_standard_output
@@ -61,7 +62,15 @@ class Tile
   end
 
   def items_contain_flora?
-    items.any? { |i| i.is_a?(Flora) }
+    items_contain?(Flora)
+  end
+
+  def items_contain_building?
+    items_contain?(Building)
+  end
+
+  def items_contain?(item_class)
+    items.any? { |i| i.is_a?(item_class) }
   end
 
   def to_h
@@ -77,6 +86,10 @@ class Tile
     }
   end
 
+  def add_town_item(seed)
+    add_item(Building.random_town_building(seed))
+  end
+
   def make_road
     @type = :road
   end
@@ -89,8 +102,16 @@ class Tile
     height
   end
 
-  def can_contain_road?
-    return true unless biome_is_water_and_is_excluded? || biome_is_high_mountain_and_is_excluded? || tile_contains_flora_and_is_excluded?
+  def can_haz_town?
+    !road? && !biome.water? && !biome.high_mountain? && !items_contain_flora?
+  end
+
+  def can_haz_road?
+    true unless biome_is_water_and_is_excluded? || biome_is_high_mountain_and_is_excluded? || tile_contains_flora_and_is_excluded? || items_contain_building?
+  end
+
+  def add_flora
+    add_item(biome.flora)
   end
 
   private
@@ -121,19 +142,4 @@ class Tile
       end
     end
   end
-
-  def items_generated_with_flora_if_applicable
-    if map.config.generate_flora && biome.flora_available
-      range_max_value = map.tiles[(y - biome.flora_range)...(y + biome.flora_range)]&.map do |r|
-        r[(x - biome.flora_range)...(x + biome.flora_range)]
-      end&.flatten&.map(&:height)&.max
-      if range_max_value == height
-        [biome.flora]
-      else
-        []
-      end
-    else
-      []
-    end
-  end
 end

data/lib/town_generator.rb

@@ -0,0 +1,154 @@
+# frozen_string_literal: true
+
+require 'poisson_disk_sampling/sampler'
+require 'poisson_disk_sampling/sample_area'
+require 'road_generator'
+require 'map_config'
+
+#
+# Generates building tile items using Poisson Disk Sampling for the given tiles
+# Roads are generated between the buildings and between towns using A* pathfinding
+#
+class TownGenerator
+  attr_reader :sample_area, :road_generator
+
+  def initialize(tiles, seed: MapConfig::DEFAULT_TOWN_SEED)
+    @sample_area = PoissonDiskSampling::SampleArea.new(grid: tiles)
+    @road_generator = RoadGenerator.new(tiles)
+    @seed = seed
+    @all_town_points = []
+  end
+
+  def generate_random_towns(config)
+    return if config.towns <= 0
+
+    puts "generating #{config.towns} random towns..." if config.verbose
+
+    @all_town_points.concat(iterate_through_towns(config.towns) do |n|
+      generate_random_town(n, config.verbose)
+    end)
+
+    generate_roads_between_towns(config.verbose)
+  end
+
+  def generate_towns_from_coordinate_list(config)
+    return unless (config.towns_to_make.length % 4).zero?
+
+    puts "generating #{config.towns_to_make.length / 4} coordinate towns..." if config.verbose
+
+    @all_town_points.concat(iterate_through_towns((config.towns_to_make.length / 4)) do |n|
+      town_values = config.towns_to_make[(n - 1) * 4..].take(4)
+      generate_town(n, town_values[2], town_values[3], [sample_area[town_values[0], town_values[1]]], config.verbose)
+    end)
+
+    generate_roads_between_towns(config.verbose)
+  end
+
+  private
+
+  def iterate_through_towns(num_of_towns)
+    (1..num_of_towns).map do |n|
+      town_points = yield n
+      @seed += 1000
+      town_points
+    end
+  end
+
+  def generate_random_town(town_num, verbose)
+    random_town_gen = Random.new(@seed)
+    generate_town(town_num, random_town_gen.rand(10..40), random_town_gen.rand(2..4), nil, verbose)
+  end
+
+  def generate_town(town_num, num_of_points, radius, initial_coords, verbose)
+    puts "generating town #{town_num}..." if verbose
+
+    points = generate_points_for_town(num_of_points, radius, initial_coords)
+    generate_town_roads(points, town_num, verbose)
+    points
+  end
+
+  def generate_points_for_town(num_of_points, radius, intial_coordinates)
+    points =
+      PoissonDiskSampling::Sampler.new(
+        sample_area: sample_area,
+        seed: @seed
+      ).generate_points(num_of_points, radius, intial_coordinates)
+    points.each do |point|
+      @seed += 1
+      point.add_town_item(@seed)
+    end
+    points
+  end
+
+  def generate_town_roads(points, town_num, verbose)
+    # TODO: slow, bad (complete graph) will update to use minimum tree spanning algorithm instead
+    puts "generating town #{town_num} roads..." if verbose
+
+    connected_pairs = Set.new
+    points.each_with_index do |point_one, idx_one|
+      points[idx_one + 1..].each do |point_two|
+        next if connected_pairs.include?([point_one, point_two]) || connected_pairs.include?([point_two, point_one])
+
+        road_to_building_one = place_in_front_or_behind(point_one)
+        road_to_building_two = place_in_front_or_behind(point_two)
+
+        connected_pairs.add([point_one, point_two])
+        connected_pairs.add([point_two, point_one])
+
+        next if road_to_building_one.nil? || road_to_building_two.nil?
+
+        road_generator.generate_roads_from_coordinate_list(road_to_building_one.concat(road_to_building_two), false)
+      end
+    end
+  end
+
+  def place_in_front_or_behind(point)
+    return [point.x, point.y - 1] if sample_area.point_within_bounds_and_can_have_road?(point.x, point.y - 1)
+    return [point.x, point.y + 1] if sample_area.point_within_bounds_and_can_have_road?(point.x, point.y + 1)
+    return [point.x - 1, point.y] if sample_area.point_within_bounds_and_can_have_road?(point.x - 1, point.y)
+    return [point.x + 1, point.y] if sample_area.point_within_bounds_and_can_have_road?(point.x + 1, point.y)
+
+    nil
+  end
+
+  def generate_roads_between_towns(verbose)
+    return if @all_town_points.length < 2
+
+    puts 'generating roads between towns...' if verbose
+
+    connected_pairs = Set.new
+    town_centroids = {}
+
+    @all_town_points.each_with_index do |town_one, idx_one|
+      find_town_centroid(town_one)
+
+      @all_town_points[idx_one + 1..].each do |town_two|
+        next if connected_pairs.include?([town_one, town_two]) || connected_pairs.include?([town_two, town_one])
+
+        town_one_center_x, town_one_center_y = (town_centroids[town_one] ||= find_town_centroid(town_one))
+        town_two_center_x, town_two_center_y = (town_centroids[town_two] ||= find_town_centroid(town_two))
+
+        road_generator.generate_roads_from_coordinate_list([town_one_center_x, town_one_center_y, town_two_center_x, town_two_center_y], false)
+
+        connected_pairs.add([town_one, town_two])
+        connected_pairs.add([town_two, town_one])
+      end
+    end
+  end
+
+  def find_town_centroid(points)
+    total_x = 0
+    total_y = 0
+    num_coordinates = points.length
+
+    points.each do |point|
+      total_x += point.x
+      total_y += point.y
+    end
+
+    average_x = total_x / num_coordinates.to_f
+    average_y = total_y / num_coordinates.to_f
+
+    [average_x, average_y]
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-perlin-2D-map-generator
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Tyler Matthews (matthewstyler)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-08-08 00:00:00.000000000 Z
+date: 2023-08-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: perlin
@@ -100,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.55.1
+        version: 1.56.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.55.1
+        version: 1.56.0
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -138,23 +138,30 @@ files:
 - lib/CLI/command.rb
 - lib/ansi_colours.rb
 - lib/biome.rb
+- lib/building.rb
 - lib/flora.rb
+- lib/flora_generator.rb
 - lib/map.rb
 - lib/map_config.rb
 - lib/map_tile_generator.rb
 - lib/pathfinding/a_star_finder.rb
 - lib/pathfinding/grid.rb
+- lib/pathfinding/priority_queue.rb
+- lib/poisson_disk_sampling/sample_area.rb
+- lib/poisson_disk_sampling/sampler.rb
 - lib/road_generator.rb
 - lib/tile.rb
 - lib/tile_item.rb
 - lib/tile_perlin_generator.rb
+- lib/town_generator.rb
 homepage: https://github.com/matthewstyler/ruby-perlin-2D-map-generator
 licenses:
 - MIT
 metadata:
   source_code_uri: https://github.com/matthewstyler/ruby-perlin-2D-map-generator
   bug_tracker_uri: https://github.com/matthewstyler/ruby-perlin-2D-map-generator/issues
-post_install_message:
+post_install_message: Thanks for installing! Star on github if you found this useful,
+  or raise issues and requests.
 rdoc_options: []
 require_paths:
 - lib
@@ -172,6 +179,6 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
-summary: Procedurally generate seeded and customizable 2D maps with optional roads,
-  rendered with ansi colours or described in a 2D array of hashes
+summary: Procedurally generate seeded and customizable 2D maps with optional roads
+  and towns, rendered with ansi colours or described in a 2D array of hashes
 test_files: []