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

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'set'
+require 'pathfinding/priority_queue'
+
+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)
+      came_from = {}
+      g_score = { start_node => 0 }
+      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 = open_set.pop
+
+        # Early exit if the current node is in the closed set
+        next if closed_set.include?(current)
+
+        # Mark the current node as visited
+        closed_set.add(current)
+
+        return reconstruct_path(came_from, current) if current == end_node
+
+        grid.neighbors(current).each do |neighbor|
+          tentative_g_score = g_score[current] + 1
+
+          next if closed_set.include?(neighbor) || (g_score[neighbor] && tentative_g_score >= g_score[neighbor])
+
+          came_from[neighbor] = current
+          g_score[neighbor] = tentative_g_score
+          f_score[neighbor] = g_score[neighbor] + heuristic_cost_estimate(neighbor, end_node)
+
+          open_set.push(neighbor, f_score[neighbor])
+        end
+      end
+
+      # No path found
+      []
+    end
+
+    private
+
+    def heuristic_cost_estimate(node, end_node)
+      manhattan_distance(node, end_node) +
+        (node.path_heuristic - end_node.path_heuristic) + # elevation for natural 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)
+      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_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_haz_road?
+      node_lookup = node(x + 1, y) if x < @nodes[0].size - 1
+      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_haz_road?
+      node_lookup = node(x, y + 1) if y < @nodes.size - 1
+      neighbors << node_lookup if !node_lookup.nil? && node_lookup.can_haz_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/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

@@ -0,0 +1,70 @@
+# 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
+
+    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,
+        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, 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],
+        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,28 @@
 
 require 'biome'
 require 'flora'
+require 'ansi_colours'
+require 'pry-byebug'
+require 'building'
 
 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)
@@ -32,11 +43,11 @@ class Tile
   end
 
   def items
-    @items ||= items_generated_with_flora_if_applicable
+    @items ||= []
   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 +61,18 @@ class Tile
     items.max_by(&:render_priority)
   end
 
+  def items_contain_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
     {
       x: x,
@@ -58,24 +81,65 @@ class Tile
       moist: moist,
       temp: temp,
       biome: biome.to_h,
-      items: items.map(&:to_h)
+      items: items.map(&:to_h),
+      type: type
     }
   end
 
+  def add_town_item(seed)
+    add_item(Building.random_town_building(seed))
+  end
+
+  def make_road
+    @type = :road
+  end
+
+  def road?
+    @type == :road
+  end
+
+  def path_heuristic
+    height
+  end
+
+  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
 
-  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
-        []
+  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
-    else
-      []
     end
   end
 end