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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3e6cc04acc39df3077354eadba18f3dc043c2eca6806c14429b8468990aaa9f5
-  data.tar.gz: f3ec0afeb64bea28b1c5593b1648ff1effad677fc595a00748e7fc79349138d4
+  metadata.gz: 4a4341c2583eba83e95d6ea4a9c1ee05a857bc1f5c77c6d3aeeba41f6995a656
+  data.tar.gz: 599b47f78c83dc6acd99dcde0e9aadbeb8d445fc7d9b6ef7ba8b1acbb3c15d7b
 SHA512:
-  metadata.gz: 1a5b8063ab6ce6a9dd92774686e42a4b9ecaa30a9b1d0df14676b76e4a83d9213a5d14268d3ed5945d554cc4c8eb41a128657aca4243257d04f1a40bb54a5b5c
-  data.tar.gz: 6d6e443145404ccd4d937723150b02953d5231e6a3d2b8f7287750bb79199cc5db275bdd44664d9025522a637b3f9104f852e3b652aefbe6ef395163e7b84f3e
+  metadata.gz: bbabe795544e432d7cf4e5dac2fd6f2b14dd17239d3eb2a59013ce3655bcee1873ef4edb5e6048be372c474af04234e5f7ef33806b517de1b160ea5d59b3d62f
+  data.tar.gz: 246cc08e1413e89c6929eacf4201a7895e64595067367f02ed8e758a239e18b098186e16c1c8a85900e1519fa84eb5ace115d15e094894b62825664b1059e57d

data/README.md

@@ -1,5 +1,11 @@
 # Ruby Perlin 2D Map Generator
-A gem that procedurally generates seeded and customizable 2D map using perlin noise.
+
+[![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)
+[![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.
 
 Include the gem in your project, or use the executable from the command line.
 
@@ -28,6 +34,7 @@ gem install ruby-perlin-2D-map-generator
 See Command line Usage for full customization, below are some examples. Alter the temperature, moisture or elevation seeds to alter these maps:
 
 - Plains with random terrain evens: `ruby-perlin-2D-map-generator render`
+- Plains with random terrain events and two roads: `ruby-perlin-2D-map-generator render --roads=2`
 - Desert (increase temperature, decrease moisture): `ruby-perlin-2D-map-generator render --temp=100 --moisture=-100`
 - Mountainous with lakes (increase elevation, increase moisture) `ruby-perlin-2D-map-generator render --elevation=25 --moisture=25`
 - Islands (decreaes elevation, increase moisture): `ruby-perlin-2D-map-generator render --elevation=-40 --moisture=25`
@@ -38,27 +45,61 @@ See Command line Usage for full customization, below are some examples. Alter th
 --width=int        The width of the generated map (default 128)
 --height=int       The height of the generated map (default 128)
 
+--roads=int        Add this many roads through the map,
+                     starting and ending at edges 
+                         (default 0)
+
 --hs=int           The seed for a terrains height perlin generation
                          (default 10)
 --ms=int           The seed for a terrains moist perlin generation
                          (default 300)
 --ts=int           The seed for a terrains temperature perlin generation
                          (default 3000)
+--rs=int            The seed for generating roads
+                         (default 100)
 
---elevation=float  Adjust each generated elevation by this percent (0 -
+--elevation=float  Adjust each generated elevation by this percent (-100 -
                          100) (default 0.0)
---moisture=float   Adjust each generated moisture by this percent (0 -
+--moisture=float   Adjust each generated moisture by this percent (-100 -
                          100) (default 0.0)
---temp=float       Adjust each generated temperature by this percent (0
+--temp=float       Adjust each generated temperature by this percent (-100
                          - 100) (default 0.0)
 ```
 
+## Roads and the heuristic
+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. 
+
+Roads can be configured to include/exclude generating paths thorugh water, mountains and flora.
+
+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`
+
 # Generate without rendering
 
-```bash
+```irb
 irb(main):001:0> map = Map.new
-...
-irb(main):002:0> map.describe[1][0]
+```
+
+Map can then be manipulated via traditional x,y lookup
+```irb
+map[x, y].to_h
+=>
+{:x=>0,                                                        
+ :y=>1,                                                        
+ :height=>0.29251394359649563,                                 
+ :moist=>0.29100678755603004,                                  
+ :temp=>0.6034041566100443,                                    
+ :biome=>{:name=>"deep_valley", :flora_range=>1, :colour=>"\e[48;5;47m"},
+ :items=>[]}
+```
+or the less intuitative multidimensional lookup (reversed axis):
+
+```irb
+map.tiles[y][x].to_h
 => 
 {:x=>0,                                                        
  :y=>1,                                                        
@@ -69,6 +110,20 @@ irb(main):002:0> map.describe[1][0]
  :items=>[]}
 ```
 
+or from the command line:
+
+```bash
+$ ruby-perlin-2D-map-generator describe coordinates=0,1
+
+{:x=>0,                                                        
+ :y=>1,                                                        
+ :height=>0.29251394359649563,                                 
+ :moist=>0.29100678755603004,                                  
+ :temp=>0.6034041566100443,                                    
+ :biome=>{:name=>"deep_valley", :flora_range=>1, :colour=>"\e[48;5;47m"},
+ :items=>[]}
+```
+
 # Full Command line Usage
 ```bash
 $ ruby-perlin-2D-map-generator --help
@@ -76,50 +131,80 @@ $ ruby-perlin-2D-map-generator --help
 ```bash
 Usage: ruby-perlin-2D-map-generator [OPTIONS] (DESCRIBE | RENDER)
 
-Generate a seeded customizable procedurally generated 2D map.
+Generate a seeded customizable procedurally generated 2D map with optional roads.
 Rendered in the console  using ansi colours, or described as a 2D array of
 hashes with each tiles information.
 
 Arguments:
   (DESCRIBE | RENDER)  command to run: render prints the map to standard
-                       output using ansi colors, while describe prints each
-                       tiles bionome information in the map.
+                       output using ansi colors. describe prints each tiles
+                       bionome information in the map, can be combined with the
+                       coordinates keyword to print a specific tile.
+                       (permitted: describe, render)
+
+Keywords:
+  COORDINATES=INT_LIST  Used with the describe command, only returns the given
+                        coordinate tile details
 
 Options:
-      --elevation=float  Adjust each generated elevation by this percent (0 -
-                         100) (default 0.0)
-      --fhx=float        The frequency for height generation across the x-axis
-                         (default 2.5)
-      --fhy=float        The frequency for height generation across the y-axis
-                         (default 2.5)
-      --fmx=float        The frequency for moist generation across the x-axis
-                         (default 2.5)
-      --fmy=float        The frequency for moist generation across the y-axis
-                         (default 2.5)
-      --ftx=float        The frequency for temp generation across the x-axis
-                         (default 2.5)
-      --fty=float        The frequency for temp generation across the y-axis
-                         (default 2.5)
-      --gf=bool          Generate flora, significantly affects performance
-      --height=int       The height of the generated map (default 128)
-  -h, --help             Print usage
-      --hs=int           The seed for a terrains height perlin generation
-                         (default 10)
-      --moisture=float   Adjust each generated moisture by this percent (0 -
-                         100) (default 0.0)
-      --ms=int           The seed for a terrains moist perlin generation
-                         (default 300)
-      --oh=int           Octaves for height generation (default 3)
-      --om=int           Octaves for moist generation (default 3)
-      --ot=int           Octaves for temp generation (default 3)
-      --ph=float         Persistance for height generation (default 1.0)
-      --pm=float         Persistance for moist generation (default 1.0)
-      --pt=float         Persistance for temp generation (default 1.0)
-      --temp=float       Adjust each generated temperature by this percent (0
-                         - 100) (default 0.0)
-      --ts=int           The seed for a terrains temperature perlin generation
-                         (default 3000)
-      --width=int        The width of the generated map (default 128)
+      --elevation=float                  Adjust each generated elevation by
+                                         this percent (-100 - 100) (default 0.0)
+      --fhx=float                        The frequency for height generation
+                                         across the x-axis (default 2.5)
+      --fhy=float                        The frequency for height generation
+                                         across the y-axis (default 2.5)
+      --fmx=float                        The frequency for moist generation
+                                         across the x-axis (default 2.5)
+      --fmy=float                        The frequency for moist generation
+                                         across the y-axis (default 2.5)
+      --ftx=float                        The frequency for temp generation
+                                         across the x-axis (default 2.5)
+      --fty=float                        The frequency for temp generation
+                                         across the y-axis (default 2.5)
+      --gf=bool                          Generate flora, significantly affects
+                                         performance
+      --height=int                       The height of the generated map
+                                         (default 128)
+  -h, --help                             Print usage
+      --hs=int                           The seed for a terrains height perlin
+                                         generation (default 10)
+      --moisture=float                   Adjust each generated moisture by
+                                         this percent (-100 - 100) (default 0.0)
+      --ms=int                           The seed for a terrains moist perlin
+                                         generation (default 300)
+      --oh=int                           Octaves for height generation
+                                         (default 3)
+      --om=int                           Octaves for moist generation (default
+                                         3)
+      --ot=int                           Octaves for temp generation (default
+                                         3)
+      --ph=float                         Persistance for height generation
+                                         (default 1.0)
+      --pm=float                         Persistance for moist generation
+                                         (default 1.0)
+      --pt=float                         Persistance for temp generation
+                                         (default 1.0)
+      --road_exclude_flora_path=bool     Controls if roads will run tiles
+                                         containing flora
+      --road_exclude_mountain_path=bool  Controls if roads will run through
+                                         high mountains
+      --road_exclude_water_path=bool     Controls if roads will run through
+                                         water
+      --roads=int                        Add this many roads through the map,
+                                         starting and ending at edges (default
+                                         0)
+      --roads_to_make ints               Attempt to create a road from a start
+                                         and end point (4 integers), can be
+                                         supplied multiple paths 
+                                         (default [])
+      --rs=int                           The seed for generating roads
+                                         (default 100)
+      --temp=float                       Adjust each generated temperature by
+                                         this percent (-100 - 100) (default 0.0)
+      --ts=int                           The seed for a terrains temperature
+                                         perlin generation (default 3000)
+      --width=int                        The width of the generated map
+                                         (default 128)
 
 Examples:
   Render with defaults
@@ -127,4 +212,10 @@ Examples:
 
   Render with options
     $ ruby-perlin-2D-map-generator render --elevation=-40 --moisture=25 --hs=1
+  
+  Render with roads
+    $ ruby-perlin-2D-map-generator render --roads=2
+
+  Describe tile [1, 1]
+    $ ruby-perlin-2D-map-generator describe coordinates=1,1
 ```

data/lib/CLI/command.rb

@@ -12,7 +12,7 @@ module CLI
 
       no_command
 
-      desc 'Generate a seeded customizable procedurally generated 2D map. Rendered in the console ' \
+      desc 'Generate a seeded customizable procedurally generated 2D map with optional roads. Rendered in the console ' \
            ' using ansi colours, or described as a 2D array of hashes with each tiles information.'
 
       example 'Render with defaults',
@@ -20,14 +20,37 @@ module CLI
 
       example 'Render with options',
               '  $ ruby-perlin-2D-map-generator render --elevation=-40 --moisture=25 --hs=1'
+
+      example 'Render with roads',
+              '  $ ruby-perlin-2D-map-generator render --roads=2'
+
+      example 'Describe tile [1, 1]',
+              '  $ ruby-perlin-2D-map-generator describe coordinates=1,1'
     end
 
     argument :command do
       name '(describe | render)'
       arity one
-      validate ->(v) { v.downcase == 'describe' || v.downcase == 'render' }
-      desc 'command to run: render prints the map to standard output using ansi colors, ' \
-           'while describe prints each tiles bionome information in the map.'
+      permit %w[describe render]
+      desc 'command to run: render prints the map to standard output using ansi colors. ' \
+           'describe prints each tiles bionome information in the map, can be combined with ' \
+           'the coordinates keyword to print a specific tile.'
+    end
+
+    keyword :coordinates do
+      arity one
+      convert :int_list
+      validate ->(v) { v >= 0 }
+      desc 'Used with the describe command, only returns the given coordinate tile details'
+    end
+
+    option :roads_to_make do
+      arity one
+      long '--roads_to_make ints'
+      convert :int_list
+      validate ->(v) { v >= 0 }
+      desc 'Attempt to create a road from a start and end point (4 integers), can be supplied multiple paths'
+      default MapConfig::DEFAULT_ROADS_TO_MAKE
     end
 
     option :height_seed do
@@ -199,7 +222,7 @@ module CLI
       long '--temp float'
       long '--temp=float'
 
-      desc 'Adjust each generated temperature by this percent (0 - 100)'
+      desc 'Adjust each generated temperature by this percent (-100 - 100)'
       convert ->(val) { val.to_f / 100.0 }
       validate ->(val) { val >= -1.0 && val <= 1.0 }
       default MapConfig::DEFAULT_TEMP_ADJUSTMENT
@@ -209,7 +232,7 @@ module CLI
       long '--elevation float'
       long '--elevation=float'
 
-      desc 'Adjust each generated elevation by this percent (0 - 100)'
+      desc 'Adjust each generated elevation by this percent (-100 - 100)'
       convert ->(val) { val.to_f / 100.0 }
       validate ->(val) { val >= -1.0 && val <= 1.0 }
       default MapConfig::DEFAULT_HEIGHT_ADJUSTMENT
@@ -219,12 +242,58 @@ module CLI
       long '--moisture float'
       long '--moisture=float'
 
-      desc 'Adjust each generated moisture by this percent (0 - 100)'
+      desc 'Adjust each generated moisture by this percent (-100 - 100)'
       convert ->(val) { val.to_f / 100.0 }
       validate ->(val) { val >= -1.0 && val <= 1.0 }
       default MapConfig::DEFAULT_MOIST_ADJUSTMENT
     end
 
+    option :roads do
+      long '--roads int'
+      long '--roads=int'
+
+      desc 'Add this many roads through the map, starting and ending at edges'
+      convert Integer
+      validate ->(val) { val >= 0 }
+      default MapConfig::DEFAULT_NUM_OF_ROADS
+    end
+
+    option :road_seed do
+      long '--rs int'
+      long '--rs=int'
+
+      desc 'The seed for generating roads'
+      convert Integer
+      default MapConfig::DEFAULT_ROAD_SEED
+    end
+
+    option :road_exclude_water_path do
+      long '--road_exclude_water_path bool'
+      long '--road_exclude_water_path=bool'
+
+      desc 'Controls if roads will run through water'
+      convert :bool
+      default MapConfig::DEFAULT_ROAD_EXCLUDE_WATER_PATH
+    end
+
+    option :road_exclude_mountain_path do
+      long '--road_exclude_mountain_path bool'
+      long '--road_exclude_mountain_path=bool'
+
+      desc 'Controls if roads will run through high mountains'
+      convert :bool
+      default MapConfig::DEFAULT_ROAD_EXCLUDE_MOUNTAIN_PATH
+    end
+
+    option :road_exclude_flora_path do
+      long '--road_exclude_flora_path bool'
+      long '--road_exclude_flora_path=bool'
+
+      desc 'Controls if roads will run tiles containing flora'
+      convert :bool
+      default MapConfig::DEFAULT_ROAD_EXCLUDE_FLORA_PATH
+    end
+
     flag :help do
       short '-h'
       long '--help'
@@ -248,14 +317,13 @@ module CLI
       map = Map.new(map_config: MapConfig.new(
         width: params[:width],
         height: params[:height],
-        perlin_height_config: perlin_height_config,
-        perlin_moist_config: perlin_moist_config,
-        perlin_temp_config: perlin_temp_config,
-        generate_flora: params[:generate_flora]
+        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)
       ))
       case params[:command]
       when 'render' then map.render
-      when 'describe' then puts map.describe
+      when 'describe' then puts(!params[:coordinates].nil? ? map[params[:coordinates][0], params[:coordinates][1]].to_h : map.describe)
       end
     end
 

data/lib/ansi_colours.rb

@@ -26,6 +26,9 @@ module AnsiColours
     TAIGA_HIGHLAND = "\e[48;5;65m"
     TAIGA_COAST = "\e[48;5;17m"
     ICE = "\e[48;5;159m"
+    LOW_ROAD_BLACK = "\e[48;5;241m"
+    ROAD_BLACK = "\e[48;5;239m"
+    HIGH_ROAD_BLACK = "\e[48;5;236m"
     ANSI_RESET = "\033[0m"
   end
 end

data/lib/biome.rb

@@ -32,6 +32,10 @@ class Biome
     TAIGA_TERRAIN.include?(self)
   end
 
+  def high_mountain?
+    HIGH_MOUNTAIN.include?(self)
+  end
+
   def flora_available
     !flora_range.nil?
   end
@@ -132,6 +136,12 @@ class Biome
     TAIGA_COAST
   ].freeze
 
+  HIGH_MOUNTAIN = [
+    SNOW,
+    ROCKS,
+    MOUNTAIN
+  ].freeze
+
   LAND_TERRAIN = (ALL_TERRAIN - WATER_TERRAIN).freeze
 
   class << self

data/lib/map.rb

@@ -2,6 +2,7 @@
 
 require 'map_tile_generator'
 require 'map_config'
+require 'road_generator'
 
 class Map
   attr_reader :config
@@ -21,7 +22,27 @@ class Map
     end
   end
 
+  # rubocop:disable Naming/MethodParameterName:
+  def [](x, y)
+    raise ArgumentError, 'coordinates out of bounds' if y.nil? || y >= tiles.size || x.nil? || x >= tiles[y].size
+
+    tiles[y][x]
+  end
+  # rubocop:enable Naming/MethodParameterName:
+
   def tiles
-    @tiles ||= MapTileGenerator.new(map: self).generate
+    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)
+    @tiles
+  end
+
+  private
+
+  def generate_tiles
+    MapTileGenerator.new(map: self).generate
   end
 end

data/lib/map_config.rb

@@ -25,25 +25,43 @@ class MapConfig
   DEFAULT_TEMP_X_FREQUENCY = 2.5
   DEFAULT_TEMP_ADJUSTMENT  = 0.0
 
+  DEFAULT_ROAD_SEED                  = 100
+  DEFAULT_NUM_OF_ROADS               = 0
+  DEFAULT_ROAD_EXCLUDE_WATER_PATH    = true
+  DEFAULT_ROAD_EXCLUDE_MOUNTAIN_PATH = true
+  DEFAULT_ROAD_EXCLUDE_FLORA_PATH    = true
+  DEFAULT_ROADS_TO_MAKE              = [].freeze
+
   PERLIN_CONFIG_OPTIONS = %i[width height noise_seed octaves x_frequency y_frequency persistance adjustment].freeze
-  PerlinConfig = Struct.new(*PERLIN_CONFIG_OPTIONS)
+  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
 
-  attr_reader :generate_flora, :perlin_height_config, :perlin_moist_config, :perlin_temp_config, :width, :height
+  PerlinConfig = Struct.new(*PERLIN_CONFIG_OPTIONS)
+  AllPerlinConfigs = Struct.new(*ALL_PERLIN_CONFIGS)
+  RoadConfig = Struct.new(*ROAD_CONFIG_OPTIONS)
 
-  def initialize(perlin_height_config: default_perlin_height_config, perlin_moist_config: default_perlin_moist_config, perlin_temp_config: default_perlin_temp_config, width: DEFAULT_TILE_COUNT,
-                 height: DEFAULT_TILE_COUNT, generate_flora: DEFAULT_GENERATE_FLORA)
-    raise ArgumentError unless perlin_height_config.is_a?(PerlinConfig) && perlin_moist_config.is_a?(PerlinConfig)
+  attr_reader :generate_flora, :perlin_height_config, :perlin_moist_config, :perlin_temp_config, :width, :height, :road_config
 
+  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)
+    validate(all_perlin_configs)
     @generate_flora = generate_flora
-    @perlin_height_config = perlin_height_config
-    @perlin_moist_config = perlin_moist_config
-    @perlin_temp_config = perlin_temp_config
+    @perlin_height_config = all_perlin_configs.perlin_height_config
+    @perlin_moist_config = all_perlin_configs.perlin_moist_config
+    @perlin_temp_config = all_perlin_configs.perlin_temp_config
     @width = width
     @height = height
+    @road_config = road_config
   end
 
   private
 
+  def validate(all_perlin_configs)
+    unless all_perlin_configs.perlin_height_config.is_a?(PerlinConfig) && all_perlin_configs.perlin_moist_config.is_a?(PerlinConfig) && all_perlin_configs.perlin_temp_config.is_a?(PerlinConfig)
+      raise ArgumentError
+    end
+  end
+
   def default_perlin_height_config
     PerlinConfig.new(DEFAULT_TILE_COUNT, DEFAULT_TILE_COUNT, DEFAULT_HEIGHT_SEED, DEFAULT_HEIGHT_OCTAVES,
                      DEFAULT_HEIGHT_X_FREQUENCY, DEFAULT_HEIGHT_Y_FREQUENCY, DEFAULT_HEIGHT_PERSISTANCE, DEFAULT_HEIGHT_ADJUSTMENT)
@@ -58,4 +76,12 @@ class MapConfig
     PerlinConfig.new(DEFAULT_TILE_COUNT, DEFAULT_TILE_COUNT, DEFAULT_TEMP_SEED, DEFAULT_TEMP_OCTAVES,
                      DEFAULT_TEMP_X_FREQUENCY, DEFAULT_TEMP_Y_FREQUENCY, DEFAULT_TEMP_PERSISTANCE, DEFAULT_TEMP_ADJUSTMENT)
   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)
+  end
+
+  def default_perlin_configs
+    AllPerlinConfigs.new(default_perlin_height_config, default_perlin_moist_config, default_perlin_temp_config)
+  end
 end

data/lib/pathfinding/a_star_finder.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Pathfinding
+  #
+  # An A* Pathfinder to build roads/paths between two coordinates containing
+  # different path costs, the heuristic behaviour that can be altered via configuration
+  #
+  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) }
+
+      until open_set.empty?
+        current_node = open_set.min_by { |node| f_score[node] }
+
+        return reconstruct_path(came_from, current_node) if current_node == end_node
+
+        open_set.delete(current_node)
+
+        grid.neighbors(current_node).each do |neighbor|
+          tentative_g_score = g_score[current_node] + 1
+
+          next unless !g_score[neighbor] || tentative_g_score < g_score[neighbor]
+
+          came_from[neighbor] = current_node
+          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)
+        end
+      end
+
+      # No path found
+      []
+    end
+
+    private
+
+    def heuristic_cost_estimate(node, end_node)
+      (node.x - end_node.x).abs +
+        (node.y - end_node.y).abs +
+        (node.path_heuristic - end_node.path_heuristic) + # elevation for natural roads
+        (node.road? ? 0 : 5) # share existing roads
+    end
+
+    def reconstruct_path(came_from, current_node)
+      path = [current_node]
+      while came_from[current_node]
+        current_node = came_from[current_node]
+        path.unshift(current_node)
+      end
+      path
+    end
+  end
+end

data/lib/pathfinding/grid.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Pathfinding
+  #
+  # Responsible for manipulating and encapsulating behaviour of tiles related
+  # to pathfinding
+  #
+  class Grid
+    attr_reader :nodes
+
+    def initialize(nodes)
+      @nodes = nodes
+    end
+
+    # rubocop:disable Naming/MethodParameterName:
+    def node(x, y)
+      nodes[y][x]
+    end
+    # rubocop:enable Naming/MethodParameterName:
+
+    def neighbors(node)
+      neighbors = []
+      return neighbors unless node.can_contain_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?
+      node_lookup = node(x + 1, y) if x < @nodes[0].size - 1
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_road?
+      node_lookup = node(x, y - 1) if y.positive?
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_contain_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
+    end
+
+    def min_max_coordinates
+      @min_max_coordinates ||= begin
+        min_x = nil
+        min_y = nil
+        max_x = nil
+        max_y = nil
+
+        @nodes.each do |row|
+          row.each do |object|
+            x = object.x
+            y = object.y
+
+            # Update minimum x and y values
+            min_x = x if min_x.nil? || x < min_x
+            min_y = y if min_y.nil? || y < min_y
+
+            # Update maximum x and y values
+            max_x = x if max_x.nil? || x > max_x
+            max_y = y if max_y.nil? || y > max_y
+          end
+        end
+
+        { min_x: min_x, min_y: min_y, max_x: max_x, max_y: max_y }
+      end
+    end
+
+    def edge_nodes
+      @edge_nodes ||=
+        @nodes.map do |row|
+          row.select do |obj|
+            obj.x == min_max_coordinates[:min_x] ||
+              obj.x == min_max_coordinates[:max_x] ||
+              obj.y == min_max_coordinates[:min_y] ||
+              obj.y == min_max_coordinates[:max_y]
+          end
+        end.flatten
+    end
+  end
+end

data/lib/road_generator.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require 'pathfinding/grid'
+require 'pathfinding/a_star_finder'
+
+#
+# Generates roads across map tiles, randomly or given specific coordinates
+#
+class RoadGenerator
+  attr_reader :grid, :finder
+
+  def initialize(tiles)
+    @grid = Pathfinding::Grid.new(tiles)
+    @finder = Pathfinding::AStarFinder.new
+  end
+
+  def generate_num_of_random_roads(config)
+    return if config.roads <= 0
+
+    seed = config.road_seed
+    (1..config.roads).each do |n|
+      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,
+        random_objects_at_edges[0].y,
+        random_objects_at_edges[1].x,
+        random_objects_at_edges[1].y
+      ).each(&:make_road)
+    end
+  end
+
+  def generate_roads_from_coordinate_list(road_paths)
+    road_paths.each_slice(4) do |road_coordinates|
+      generate_path(
+        road_coordinates[0],
+        road_coordinates[1],
+        road_coordinates[2],
+        road_coordinates[3]
+      ).each(&:make_road)
+    end
+  end
+
+  def generate_path(start_x, start_y, end_x, end_y)
+    start_node = grid.node(start_x, start_y)
+    end_node = grid.node(end_x, end_y)
+    finder.find_path(start_node, end_node, grid)
+  end
+
+  private
+
+  def random_nodes_not_on_same_edge(seed)
+    random_generator = Random.new(seed)
+    length = @grid.edge_nodes.length
+
+    loop do
+      index1 = random_generator.rand(length)
+      index2 = random_generator.rand(length)
+      node_one, node_two = @grid.edge_nodes.values_at(index1, index2)
+
+      return [node_one, node_two] if node_one.x != node_two.x && node_one.y != node_two.y
+    end
+  end
+end

data/lib/tile.rb

@@ -2,17 +2,27 @@
 
 require 'biome'
 require 'flora'
+require 'ansi_colours'
+require 'pry-byebug'
 
 class Tile
-  attr_reader :x, :y, :height, :moist, :temp, :map
+  attr_reader :x, :y, :height, :moist, :temp, :map, :type
 
-  def initialize(map:, x:, y:, height: 0, moist: 0, temp: 0)
+  TYPES = %i[
+    terrain
+    road
+  ].freeze
+
+  def initialize(map:, x:, y:, height: 0, moist: 0, temp: 0, type: :terrain)
     @x = x
     @y = y
     @height = height
     @moist = moist
     @temp = temp
     @map = map
+    raise ArgumentError, 'invalid tile type' unless TYPES.include?(type)
+
+    @type = type
   end
 
   def surrounding_tiles(distance = 1)
@@ -36,7 +46,7 @@ class Tile
   end
 
   def render_to_standard_output
-    print biome.colour + (!items.empty? ? item_with_highest_priority.render_symbol : '  ')
+    print render_color_by_type + (!items.empty? ? item_with_highest_priority.render_symbol : '  ')
     print AnsiColours::Background::ANSI_RESET
   end
 
@@ -50,6 +60,10 @@ class Tile
     items.max_by(&:render_priority)
   end
 
+  def items_contain_flora?
+    items.any? { |i| i.is_a?(Flora) }
+  end
+
   def to_h
     {
       x: x,
@@ -58,12 +72,56 @@ class Tile
       moist: moist,
       temp: temp,
       biome: biome.to_h,
-      items: items.map(&:to_h)
+      items: items.map(&:to_h),
+      type: type
     }
   end
 
+  def make_road
+    @type = :road
+  end
+
+  def road?
+    @type == :road
+  end
+
+  def path_heuristic
+    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?
+  end
+
   private
 
+  def biome_is_water_and_is_excluded?
+    biome.water? && map.config.road_config.road_exclude_water_path
+  end
+
+  def biome_is_high_mountain_and_is_excluded?
+    biome.high_mountain? && map.config.road_config.road_exclude_mountain_path
+  end
+
+  def tile_contains_flora_and_is_excluded?
+    items_contain_flora? && map.config.road_config.road_exclude_flora_path
+  end
+
+  def render_color_by_type
+    case type
+    when :terrain then biome.colour
+    when :road
+      case height
+      when 0.66..1
+        AnsiColours::Background::HIGH_ROAD_BLACK
+      when 0.33..0.66
+        AnsiColours::Background::ROAD_BLACK
+      when 0..0.33
+        AnsiColours::Background::LOW_ROAD_BLACK
+      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|

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-perlin-2D-map-generator
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Tyler Matthews (matthewstyler)
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-07-08 00:00:00.000000000 Z
+date: 2023-08-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: perlin
@@ -58,14 +58,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.4
+        version: 2.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.4
+        version: 2.1.0
+- !ruby/object:Gem::Dependency
+  name: pry-byebug
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.10.1
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -86,14 +100,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.54.1
+        version: 1.55.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.54.1
+        version: 1.55.1
 - !ruby/object:Gem::Dependency
   name: simplecov
   requirement: !ruby/object:Gem::Requirement
@@ -108,10 +122,10 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.22.0
-description: A gem that procedurally generates a seeded and customizable 2D map using
-  perlin noise. Map can be rendered in console using ansi colors or returned as 2D
-  array of hashes describing each tile and binome. Completelycustomizable, use the
-  --help option for full usage details.
+description: A gem that procedurally generates a seeded and customizable 2D map with
+  optional roads using perlin noise. 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.
 email: matthews.tyl@gmail.com
 executables:
 - ruby-perlin-2D-map-generator
@@ -128,6 +142,9 @@ files:
 - lib/map.rb
 - lib/map_config.rb
 - lib/map_tile_generator.rb
+- lib/pathfinding/a_star_finder.rb
+- lib/pathfinding/grid.rb
+- lib/road_generator.rb
 - lib/tile.rb
 - lib/tile_item.rb
 - lib/tile_perlin_generator.rb
@@ -155,6 +172,6 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key:
 specification_version: 4
-summary: Procedurally generate seeded and customizable 2D maps, rendered with ansi
-  colours or described in a 2D array of hashes
+summary: Procedurally generate seeded and customizable 2D maps with optional roads,
+  rendered with ansi colours or described in a 2D array of hashes
 test_files: []