ruby-perlin-2D-map-generator 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 59f285c1212afff796f6788a429ce6165cd782527330d9a2130f5bf444cae048
+  data.tar.gz: cb54ce932c804c506f26ad66523fa35e8ca37d274b89ab6a345c6a263dff75b0
+SHA512:
+  metadata.gz: d9790b03d89b999a94be35a5c0d7aff5a81d844c06a8a52fcfbdd63e4923aee49353e0319d69d1ab108d8b3de0e5a6a8998d396481c7014037a122dd4ed48e6a
+  data.tar.gz: f85761e76b1294b5ff318ddfd14d947f34586f1f4241ee61f42972cfa1f0c21649b288c3e48bb200134ba13338f2e3bb26fa1037d0fcf5e07c6ace87a5828592

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tyler Matthews
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,99 @@
+# Ruby Perlin 2D Map Generator
+A gem that procedurally generates seeded and customizable 2D map 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/89b4f623-53e3-445e-8e5b-96f4fcf67af5)
+
+# Customization examples
+
+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`
+- 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`
+- Taiga map (decrease temperature, increase moisture): `ruby-perlin-2D-map-generator render --temp=-60 --moisture=30 `
+
+## Common customization
+```bash
+--width=int        The width of the generated map (default 128)
+--height=int       The height of the generated map (default 128)
+
+--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)
+
+--elevation=float  Adjust each generated elevation by this percent (0 -
+                         100) (default 0.0)
+--moisture=float   Adjust each generated moisture by this percent (0 -
+                         100) (default 0.0)
+--temp=float       Adjust each generated temperature by this percent (0
+                         - 100) (default 0.0)
+```
+
+# Full Command line Usage
+```bash
+$ ruby-perlin-2D-map-generator --help
+```
+```bash
+Usage: ruby-perlin-2D-map-generator [OPTIONS] (DESCRIBE | RENDER)
+
+Generate a seeded customizable procedurally generated 2D map.
+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.
+
+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)
+
+Examples:
+  Render with defaults
+    $ ruby-perlin-2D-map-generator render
+
+  Render with options
+    $ ruby-perlin-2D-map-generator render --elevation=-40 --moisture=25 --hs=1
+```

data/bin/ruby-perlin-2D-map-generator

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+lib_path = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib_path) unless $LOAD_PATH.include?(lib_path)
+require 'CLI/command'
+
+Signal.trap('INT') do
+  warn("\n#{caller.join("\n")}: interrupted")
+  exit(1)
+end
+
+CLI::Command.new.parse.run

data/lib/CLI/command.rb

@@ -0,0 +1,277 @@
+# frozen_string_literal: true
+
+require 'tty/option'
+require 'map'
+require 'map_config'
+module CLI
+  class Command
+    include TTY::Option
+
+    usage do
+      program 'ruby-perlin-2D-map-generator'
+
+      no_command
+
+      desc 'Generate a seeded customizable procedurally generated 2D map. Rendered in the console ' \
+           ' using ansi colours, or described as a 2D array of hashes with each tiles information.'
+
+      example 'Render with defaults',
+              '  $ ruby-perlin-2D-map-generator render'
+
+      example 'Render with options',
+              '  $ ruby-perlin-2D-map-generator render --elevation=-40 --moisture=25 --hs=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.'
+    end
+
+    option :height_seed do
+      long '--hs int'
+      # or
+      long '--hs=int'
+
+      desc 'The seed for a terrains height perlin generation'
+      convert Integer
+      default MapConfig::DEFAULT_HEIGHT_SEED
+    end
+
+    option :moist_seed do
+      long '--ms int'
+      # or
+      long '--ms=int'
+
+      desc 'The seed for a terrains moist perlin generation'
+      convert Integer
+      default MapConfig::DEFAULT_MOIST_SEED
+    end
+
+    option :temp_seed do
+      long '--ts int'
+      # or
+      long '--ts=int'
+
+      desc 'The seed for a terrains temperature perlin generation'
+      convert Integer
+      default MapConfig::DEFAULT_TEMP_SEED
+    end
+
+    option :octaves_height do
+      long '--oh int'
+      long '--oh=int'
+
+      desc 'Octaves for height generation'
+      convert Integer
+      default MapConfig::DEFAULT_HEIGHT_OCTAVES
+    end
+
+    option :octaves_moist do
+      long '--om int'
+      long '--om=int'
+
+      desc 'Octaves for moist generation'
+      convert Integer
+      default MapConfig::DEFAULT_MOIST_OCTAVES
+    end
+
+    option :octaves_temp do
+      long '--ot int'
+      long '--ot=int'
+
+      desc 'Octaves for temp generation'
+      convert Integer
+      default MapConfig::DEFAULT_TEMP_OCTAVES
+    end
+
+    option :persistance_moist do
+      long '--pm float'
+      long '--pm=float'
+
+      desc 'Persistance for moist generation'
+      convert Float
+      default MapConfig::DEFAULT_MOIST_PERSISTANCE
+    end
+
+    option :persistance_height do
+      long '--ph float'
+      long '--ph=float'
+
+      desc 'Persistance for height generation'
+      convert Float
+      default MapConfig::DEFAULT_HEIGHT_PERSISTANCE
+    end
+
+    option :persistance_temp do
+      long '--pt float'
+      long '--pt=float'
+
+      desc 'Persistance for temp generation'
+      convert Float
+      default MapConfig::DEFAULT_TEMP_PERSISTANCE
+    end
+
+    option :width do
+      long '--width int'
+      long '--width=int'
+
+      desc 'The width of the generated map'
+      convert Integer
+      default MapConfig::DEFAULT_TILE_COUNT
+    end
+
+    option :height do
+      long '--height int'
+      long '--height=int'
+
+      desc 'The height of the generated map'
+      convert Integer
+      default MapConfig::DEFAULT_TILE_COUNT
+    end
+
+    option :perlin_height_horizontal_frequency do
+      long '--fhx float'
+      long '--fhx=float'
+
+      desc 'The frequency for height generation across the x-axis'
+      convert Float
+      default MapConfig::DEFAULT_HEIGHT_X_FREQUENCY
+    end
+
+    option :perlin_height_vertical_frequency do
+      long '--fhy float'
+      long '--fhy=float'
+
+      desc 'The frequency for height generation across the y-axis'
+      convert Float
+      default MapConfig::DEFAULT_HEIGHT_Y_FREQUENCY
+    end
+
+    option :perlin_temp_horizontal_frequency do
+      long '--ftx float'
+      long '--ftx=float'
+
+      desc 'The frequency for temp generation across the x-axis'
+      convert Float
+      default MapConfig::DEFAULT_TEMP_X_FREQUENCY
+    end
+
+    option :perlin_temp_vertical_frequency do
+      long '--fty float'
+      long '--fty=float'
+
+      desc 'The frequency for temp generation across the y-axis'
+      convert Float
+      default MapConfig::DEFAULT_TEMP_Y_FREQUENCY
+    end
+
+    option :perlin_moist_horizontal_frequency do
+      long '--fmx float'
+      long '--fmx=float'
+
+      desc 'The frequency for moist generation across the x-axis'
+      convert Float
+      default MapConfig::DEFAULT_MOIST_X_FREQUENCY
+    end
+
+    option :perlin_moist_vertical_frequency do
+      long '--fmy float'
+      long '--fmy=float'
+
+      desc 'The frequency for moist generation across the y-axis'
+      convert Float
+      default MapConfig::DEFAULT_MOIST_Y_FREQUENCY
+    end
+
+    option :generate_flora do
+      long '--gf bool'
+      long '--gf=bool'
+
+      desc 'Generate flora, significantly affects performance'
+      convert :bool
+      default MapConfig::DEFAULT_GENERATE_FLORA
+    end
+
+    option :temp do
+      long '--temp float'
+      long '--temp=float'
+
+      desc 'Adjust each generated temperature by this percent (0 - 100)'
+      convert ->(val) { val.to_f / 100.0 }
+      validate ->(val) { val >= -1.0 && val <= 1.0 }
+      default MapConfig::DEFAULT_TEMP_ADJUSTMENT
+    end
+
+    option :elevation do
+      long '--elevation float'
+      long '--elevation=float'
+
+      desc 'Adjust each generated elevation by this percent (0 - 100)'
+      convert ->(val) { val.to_f / 100.0 }
+      validate ->(val) { val >= -1.0 && val <= 1.0 }
+      default MapConfig::DEFAULT_HEIGHT_ADJUSTMENT
+    end
+
+    option :moisture do
+      long '--moisture float'
+      long '--moisture=float'
+
+      desc 'Adjust each generated moisture by this percent (0 - 100)'
+      convert ->(val) { val.to_f / 100.0 }
+      validate ->(val) { val >= -1.0 && val <= 1.0 }
+      default MapConfig::DEFAULT_MOIST_ADJUSTMENT
+    end
+
+    flag :help do
+      short '-h'
+      long '--help'
+      desc 'Print usage'
+    end
+
+    def run
+      if params[:help]
+        print help
+      elsif params.errors.any?
+        puts params.errors.summary
+      else
+        execute_command
+        # pp params.to_h
+      end
+    end
+
+    private
+
+    def execute_command
+      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]
+      ))
+      case params[:command]
+      when 'render' then map.render
+      when 'describe' then puts map.describe
+      end
+    end
+
+    def perlin_moist_config
+      MapConfig::PerlinConfig.new(*params.to_h.slice(:width, :height, :moist_seed, :octaves_moist,
+                                                     :perlin_moist_horizontal_frequency, :perlin_moist_vertical_frequency, :persistance_moist, :moisture).values)
+    end
+
+    def perlin_height_config
+      MapConfig::PerlinConfig.new(*params.to_h.slice(:width, :height, :height_seed, :octaves_height,
+                                                     :perlin_height_horizontal_frequency, :perlin_height_vertical_frequency, :persistance_height, :elevation).values)
+    end
+
+    def perlin_temp_config
+      MapConfig::PerlinConfig.new(*params.to_h.slice(:width, :height, :temp_seed, :octaves_temp,
+                                                     :perlin_temp_horizontal_frequency, :perlin_temp_vertical_frequency, :persistance_temp, :temp).values)
+    end
+  end
+end

data/lib/ansi_colours.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module AnsiColours
+  module Background
+    WHITE = "\e[48;5;231m"
+    BLACK = "\033[40m"
+    DEEP_BLUE = "\033[48;5;23m"
+    BLUE = "\033[44m"
+    LIGHT_BLUE = "\033[48;5;117m"
+    SHOAL_BLUE = "\e[48;5;87m"
+    GREEN = "\033[102m"
+    LIGHT_GREEN = "\e[48;5;47m"
+    DESERT_YELLOW = "\e[48;5;220m"
+    DESERT_LIGHT_YELLOW = "\e[48;5;223m"
+    DESERT_DARK_YELLOW = "\e[48;5;214m"
+    GREEN_SWAMP = "\e[48;5;58m"
+    DARK_GREEN = "\033[42m"
+    BROWN = "\033[48;5;130m"
+    GREY = "\e[48;5;7m"
+    GREY_MOUNTAIN = "\033[38;5;240m"
+    SANDY = "\033[48;5;229m"
+    RED_BROWN = "\033[48;5;173m"
+    GRASSLAND = "\033[48;2;195;205;103m"
+    TAIGA_PLAIN = "\e[48;5;67m"
+    TAIGA_VALLEY = "\e[48;5;66m"
+    TAIGA_HIGHLAND = "\e[48;5;65m"
+    TAIGA_COAST = "\e[48;5;17m"
+    ICE = "\e[48;5;159m"
+    ANSI_RESET = "\033[0m"
+  end
+end

data/lib/biome.rb

@@ -0,0 +1,225 @@
+# frozen_string_literal: true
+
+require 'ansi_colours'
+require 'flora'
+
+class Biome
+  attr_accessor :name, :flora_range, :colour
+
+  def initialize(name:, colour:, flora_range: nil)
+    @name = name
+    @flora_range = flora_range
+    @colour = colour
+  end
+
+  def water?
+    WATER_TERRAIN.include?(self)
+  end
+
+  def land?
+    LAND_TERRAIN.include?(self)
+  end
+
+  def grassland?
+    GRASSLAND_TERRAIN.include?(self)
+  end
+
+  def desert?
+    DESERT_TERRAIN.include?(self)
+  end
+
+  def taiga?
+    TAIGA_TERRAIN.include?(self)
+  end
+
+  def flora_available
+    !flora_range.nil?
+  end
+
+  def flora
+    @flora ||=
+      if flora_available
+        if desert?
+          Flora.new(Flora::CACTUS)
+        elsif grassland?
+          Flora.new(Flora::DECIDUOUS_TREE)
+        elsif taiga?
+          Flora.new(Flora::EVERGREEN_TREE)
+        else
+          raise StandardError, "Unknown flora #{to_h}"
+        end
+      end
+  end
+
+  def to_h
+    {
+      name: name,
+      flora_range: flora_range,
+      colour: colour
+    }
+  end
+
+  def self.from(elevation, moist, temp)
+    terrain_selection(elevation, moist, temp)
+  end
+
+  SNOW                        = Biome.new(name: 'snow', flora_range: nil, colour: AnsiColours::Background::WHITE)
+  ROCKS                       = Biome.new(name: 'rocks', flora_range: nil, colour: AnsiColours::Background::GREY)
+  MOUNTAIN                    = Biome.new(name: 'mountain', flora_range: nil, colour: AnsiColours::Background::BROWN)
+  MOUNTAIN_FOOT               = Biome.new(name: 'mountain_foot', flora_range: 10, colour: AnsiColours::Background::RED_BROWN)
+  GRASSLAND                   = Biome.new(name: 'grassland', flora_range: 1, colour: AnsiColours::Background::DARK_GREEN)
+  VALLEY                      = Biome.new(name: 'valley', flora_range: 1, colour: AnsiColours::Background::GREEN)
+  DEEP_VALLEY                 = Biome.new(name: 'deep_valley', flora_range: 1, colour: AnsiColours::Background::LIGHT_GREEN)
+  DESERT                      = Biome.new(name: 'desert', flora_range: 1, colour: AnsiColours::Background::DESERT_YELLOW)
+  DEEP_DESERT                 = Biome.new(name: 'deep_desert', flora_range: 1, colour: AnsiColours::Background::DESERT_LIGHT_YELLOW)
+  STEPPE_DESERT               = Biome.new(name: 'steppe_desert', flora_range: 1, colour: AnsiColours::Background::DESERT_DARK_YELLOW)
+  SWAMP                       = Biome.new(name: 'swamp', flora_range: nil, colour: AnsiColours::Background::GREEN_SWAMP)
+  COASTLINE                   = Biome.new(name: 'coastline', flora_range: nil, colour: AnsiColours::Background::SANDY)
+  SHOAL                       = Biome.new(name: 'shoal', flora_range: nil, colour: AnsiColours::Background::SHOAL_BLUE)
+  OCEAN                       = Biome.new(name: 'ocean', flora_range: nil, colour: AnsiColours::Background::LIGHT_BLUE)
+  DEEP_OCEAN                  = Biome.new(name: 'deep_ocean', flora_range: nil, colour: AnsiColours::Background::BLUE)
+  TAIGA_PLAIN                 = Biome.new(name: 'taiga_plain', flora_range: 1.5, colour: AnsiColours::Background::TAIGA_PLAIN)
+  TAIGA_VALLEY                = Biome.new(name: 'taiga_valley', flora_range: 1.5, colour: AnsiColours::Background::TAIGA_VALLEY)
+  TAIGA_HIGHLAND              = Biome.new(name: 'taiga_highland', flora_range: 1.5, colour: AnsiColours::Background::TAIGA_HIGHLAND)
+  TAIGA_COAST                 = Biome.new(name: 'taiga_coast', flora_range: nil, colour: AnsiColours::Background::TAIGA_COAST)
+  ICE                         = Biome.new(name: 'ice', flora_range: nil, colour: AnsiColours::Background::ICE)
+
+  ALL_TERRAIN = [
+    SNOW,
+    ROCKS,
+    MOUNTAIN,
+    MOUNTAIN_FOOT,
+    GRASSLAND,
+    VALLEY,
+    COASTLINE,
+    SHOAL,
+    OCEAN,
+    DEEP_OCEAN,
+    DESERT,
+    DEEP_DESERT,
+    STEPPE_DESERT,
+    SWAMP,
+    TAIGA_PLAIN,
+    TAIGA_HIGHLAND,
+    TAIGA_VALLEY,
+    TAIGA_COAST,
+    ICE
+  ].freeze
+
+  WATER_TERRAIN = [
+    SHOAL,
+    OCEAN,
+    DEEP_OCEAN
+  ].freeze
+
+  DESERT_TERRAIN = [
+    DESERT,
+    DEEP_DESERT,
+    STEPPE_DESERT
+  ].freeze
+
+  GRASSLAND_TERRAIN = [
+    GRASSLAND,
+    VALLEY,
+    DEEP_VALLEY,
+    MOUNTAIN_FOOT
+  ].freeze
+
+  TAIGA_TERRAIN = [
+    TAIGA_PLAIN,
+    TAIGA_HIGHLAND,
+    TAIGA_VALLEY,
+    TAIGA_COAST
+  ].freeze
+
+  LAND_TERRAIN = (ALL_TERRAIN - WATER_TERRAIN).freeze
+
+  class << self
+    private
+
+    def terrain_selection(elevation, moist, temp)
+      case elevation
+      when 0.95..1
+        SNOW
+      when 0.9..0.95
+        ROCKS
+      when 0.8..0.9
+        if moist < 0.9
+          MOUNTAIN
+        else
+          SHOAL
+        end
+      when 0.7..0.8
+        if moist < 0.9
+          MOUNTAIN_FOOT
+        else
+          SHOAL
+        end
+      when 0.6..0.7
+        if moist < 0.8
+          if desert_condition?(moist, temp)
+            STEPPE_DESERT
+          elsif taiga_condition?(moist, temp)
+            TAIGA_HIGHLAND
+          elsif moist > 0.75
+            SWAMP
+          else
+            GRASSLAND
+          end
+        else
+          SHOAL
+        end
+      when 0.3..0.6
+        if desert_condition?(moist, temp)
+          DESERT
+        elsif taiga_condition?(moist, temp)
+          TAIGA_PLAIN
+        else
+          VALLEY
+        end
+      when 0.2..0.3
+        if desert_condition?(moist, temp)
+          DEEP_DESERT
+        elsif taiga_condition?(moist, temp)
+          TAIGA_VALLEY
+        else
+          DEEP_VALLEY
+        end
+      when 0.15..0.2
+        if taiga_condition?(moist, temp)
+          TAIGA_COAST
+        else
+          COASTLINE
+        end
+      when 0.05..0.15
+        if taiga_condition?(moist, temp)
+          ICE
+        else
+          SHOAL
+        end
+      when 0.025..0.05
+        if taiga_condition?(moist, temp)
+          ICE
+        else
+          OCEAN
+        end
+      when 0.0..0.025
+        if taiga_condition?(moist, temp)
+          ICE
+        else
+          DEEP_OCEAN
+        end
+      else
+        raise ArgumentError, "unknown biome elevation: #{elevation} moisture: #{moist} temp: #{temp}"
+      end
+    end
+
+    def desert_condition?(moist, temp)
+      moist < 0.1 && temp > 0.5
+    end
+
+    def taiga_condition?(moist, temp)
+      moist > 0.6 && temp < 0.2
+    end
+  end
+end

data/lib/flora.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require 'tile_item'
+
+class Flora < TileItem
+  CACTUS = "\u{1F335}"
+  EVERGREEN_TREE = "\u{1F332}"
+  DECIDUOUS_TREE = "\u{1F333}"
+
+  def initialize(render_symbol)
+    super self, render_symbol: render_symbol
+  end
+end

data/lib/map.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+require 'map_tile_generator'
+require 'map_config'
+
+class Map
+  attr_reader :config
+
+  def initialize(map_config: MapConfig.new)
+    @config = map_config
+  end
+
+  def describe
+    tiles.map { |row| row.map(&:to_h) }
+  end
+
+  def render
+    tiles.each do |row|
+      row.each(&:render_to_standard_output)
+      puts
+    end
+  end
+
+  def tiles
+    @tiles ||= MapTileGenerator.new(map: self).generate
+  end
+end

data/lib/map_config.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+class MapConfig
+  DEFAULT_TILE_COUNT = 128
+  DEFAULT_GENERATE_FLORA = true
+
+  DEFAULT_HEIGHT_SEED = 10
+  DEFAULT_HEIGHT_OCTAVES = 3
+  DEFAULT_HEIGHT_X_FREQUENCY = 2.5
+  DEFAULT_HEIGHT_Y_FREQUENCY = 2.5
+  DEFAULT_HEIGHT_PERSISTANCE = 1.0
+  DEFAULT_HEIGHT_ADJUSTMENT  = 0.0
+
+  DEFAULT_MOIST_SEED = 300
+  DEFAULT_MOIST_OCTAVES = 3
+  DEFAULT_MOIST_X_FREQUENCY = 2.5
+  DEFAULT_MOIST_Y_FREQUENCY = 2.5
+  DEFAULT_MOIST_PERSISTANCE = 1.0
+  DEFAULT_MOIST_ADJUSTMENT  = 0.0
+
+  DEFAULT_TEMP_SEED = 3000
+  DEFAULT_TEMP_OCTAVES = 3
+  DEFAULT_TEMP_PERSISTANCE = 1.0
+  DEFAULT_TEMP_Y_FREQUENCY = 2.5
+  DEFAULT_TEMP_X_FREQUENCY = 2.5
+  DEFAULT_TEMP_ADJUSTMENT  = 0.0
+
+  PERLIN_CONFIG_OPTIONS = %i[width height noise_seed octaves x_frequency y_frequency persistance adjustment].freeze
+  PerlinConfig = Struct.new(*PERLIN_CONFIG_OPTIONS)
+
+  attr_reader :generate_flora, :perlin_height_config, :perlin_moist_config, :perlin_temp_config, :width, :height
+
+  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)
+
+    @generate_flora = generate_flora
+    @perlin_height_config = perlin_height_config
+    @perlin_moist_config = perlin_moist_config
+    @perlin_temp_config = perlin_temp_config
+    @width = width
+    @height = height
+  end
+
+  private
+
+  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)
+  end
+
+  def default_perlin_moist_config
+    PerlinConfig.new(DEFAULT_TILE_COUNT, DEFAULT_TILE_COUNT, DEFAULT_MOIST_SEED, DEFAULT_MOIST_OCTAVES,
+                     DEFAULT_MOIST_X_FREQUENCY, DEFAULT_MOIST_Y_FREQUENCY, DEFAULT_MOIST_PERSISTANCE, DEFAULT_MOIST_ADJUSTMENT)
+  end
+
+  def default_perlin_temp_config
+    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
+end

data/lib/map_tile_generator.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require 'tile'
+require 'tile_perlin_generator'
+
+class MapTileGenerator
+  attr_reader :map_config, :map, :height_perlin_generator, :moist_perlin_generator, :temp_perlin_generator
+
+  def initialize(map:, height_perlin_generator: nil, moist_perlin_generator: nil, temp_perlin_generator: nil)
+    @map = map
+    @map_config = map.config
+    @height_perlin_generator = height_perlin_generator || default_perlin_height_generator
+    @moist_perlin_generator = moist_perlin_generator || default_perlin_moist_generator
+    @temp_perlin_generator = temp_perlin_generator || default_perlin_temp_generator
+  end
+
+  def generate
+    positive_quadrant_cartesian_plane
+  end
+
+  private
+
+  def positive_quadrant_cartesian_plane
+    y_axis_array do |y|
+      x_axis_array do |x|
+        Tile.new(
+          map: map,
+          x: x,
+          y: y,
+          height: heights[y][x],
+          moist: moists[y][x],
+          temp: temps[y][x]
+        )
+      end
+    end
+  end
+
+  def y_axis_array(&block)
+    Array.new(map_config.height, &block)
+  end
+
+  def x_axis_array(&block)
+    Array.new(map_config.width, &block)
+  end
+
+  def default_perlin_height_generator
+    TilePerlinGenerator.new(map_config.perlin_height_config)
+  end
+
+  def default_perlin_moist_generator
+    TilePerlinGenerator.new(map_config.perlin_moist_config)
+  end
+
+  def default_perlin_temp_generator
+    TilePerlinGenerator.new(map_config.perlin_temp_config)
+  end
+
+  def heights
+    @heights ||= height_perlin_generator.generate
+  end
+
+  def moists
+    @moists ||= moist_perlin_generator.generate
+  end
+
+  def temps
+    @temps ||= temp_perlin_generator.generate
+  end
+end

data/lib/tile.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'biome'
+require 'flora'
+
+class Tile
+  attr_reader :x, :y, :height, :moist, :temp, :map
+
+  def initialize(map:, x:, y:, height: 0, moist: 0, temp: 0)
+    @x = x
+    @y = y
+    @height = height
+    @moist = moist
+    @temp = temp
+    @map = map
+  end
+
+  def surrounding_tiles(distance = 1)
+    @surround_cache ||= {}
+    @surround_cache[distance] ||= begin
+      left_limit = [0, x - distance].max
+      top_limit  = [0, y - distance].max
+
+      map.tiles[left_limit..(x + distance)].map do |r|
+        r[top_limit..(y + distance)]
+      end.flatten
+    end
+  end
+
+  def biome
+    @biome ||= Biome.from(height, moist, temp)
+  end
+
+  def items
+    @items ||= items_generated_with_flora_if_applicable
+  end
+
+  def render_to_standard_output
+    print biome.colour + (!items.empty? ? item_with_highest_priority.render_symbol : '  ')
+    print AnsiColours::Background::ANSI_RESET
+  end
+
+  def add_item(tile_item)
+    raise ArgumentError, 'item should be a tile' unless tile_item.is_a?(TileItem)
+
+    items.push(tile_item)
+  end
+
+  def item_with_highest_priority
+    items.max_by(&:render_priority)
+  end
+
+  def to_h
+    {
+      x: x,
+      y: y,
+      height: height,
+      moist: moist,
+      temp: temp,
+      biome: biome.to_h,
+      items: items.map(&:to_h)
+    }
+  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
+        []
+      end
+    else
+      []
+    end
+  end
+end

data/lib/tile_item.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+class TileItem
+  DEFAULT_RENDER_PRIORITY = 0
+  attr_reader :obj, :id, :render_symbol, :colour, :render_priority
+
+  def initialize(obj, render_symbol:, id: object_id, render_priority: DEFAULT_RENDER_PRIORITY)
+    @obj = obj
+    @id = id
+    @render_symbol = render_symbol
+    @render_priority = render_priority
+  end
+
+  def to_h
+    {
+      id: id,
+      type: obj.class.name.downcase,
+      render_symbol: render_symbol,
+      render_priority: render_priority
+    }
+  end
+end

data/lib/tile_perlin_generator.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'perlin'
+
+class TilePerlinGenerator
+  attr_reader :perlin_config
+
+  def initialize(perlin_config)
+    @perlin_config = perlin_config
+  end
+
+  def generate
+    Array.new(perlin_config.height) do |y|
+      Array.new(perlin_config.width) do |x|
+        nx = perlin_config.x_frequency * (x.to_f / perlin_config.width - 0.5)
+        ny = perlin_config.y_frequency * (y.to_f / perlin_config.height - 0.5)
+        with_adjustment((Math.cos(noise(nx, ny))**6))
+      end
+    end
+  end
+
+  private
+
+  def with_adjustment(result)
+    if perlin_config.adjustment != 0.0
+      result += perlin_config.adjustment
+      result = [result, 1.0].min
+      [result, 0.0].max
+    else
+      result
+    end
+  end
+
+  def noise(x, y)
+    (noise_generator[x, y] / 2) + 0.5
+  end
+
+  def noise_generator
+    @noise_generator ||=
+      Perlin::Generator.new(
+        perlin_config.noise_seed,
+        perlin_config.persistance,
+        perlin_config.octaves
+      )
+  end
+end

metadata

@@ -0,0 +1,132 @@
+--- !ruby/object:Gem::Specification
+name: ruby-perlin-2D-map-generator
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Tyler Matthews (matthewstyler)
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-07-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: perlin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: tty-option
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '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.
+email: matthews.tyl@gmail.com
+executables:
+- ruby-perlin-2D-map-generator
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/ruby-perlin-2D-map-generator
+- lib/CLI/command.rb
+- lib/ansi_colours.rb
+- lib/biome.rb
+- lib/flora.rb
+- lib/map.rb
+- lib/map_config.rb
+- lib/map_tile_generator.rb
+- lib/tile.rb
+- lib/tile_item.rb
+- lib/tile_perlin_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:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+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
+test_files: []