world_in_your_terminal 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6869d27eda194e7a3ff7943230e0b9a63a4f1231d669aa3168934bc5281b8b7b
+  data.tar.gz: b4d40183401e2251d34d59ec57267929084e09cf3fec3bd7c96d97902b8c473a
+SHA512:
+  metadata.gz: 8173168e07aa1f1813c7e9530865d90447d696423dfe35885dcfec40996039d7663a6894745782424d13d7adc6ee3fe61f779f5a5731ddea96a73175766db3db
+  data.tar.gz: 30308740445c368da0e35d7db0573aa3f89caedb3b56c2bdf8027a7070cef5a2a4e641564dbee97e4da77cbcb07a2268e388cff13d972803cabd1fcbc8253e56

data/lib/Action.rb

@@ -0,0 +1,10 @@
+
+class Action
+    def initialize(callback)
+        @callback = callback
+    end
+
+    def call
+        @callback.call
+    end
+end

data/lib/Display.rb

@@ -0,0 +1,31 @@
+require_relative './constants/themes/default.rb'
+require_relative './constants/themes/black_white.rb'
+require_relative './World.rb'
+
+class Display
+    def initialize(screen_size)
+        @screen_size = screen_size
+        @world = initialize_world
+    end
+
+    def draw
+        world.draw(tile_size)
+    end
+
+    def screen_size
+        @screen_size
+    end
+
+    def tile_size
+        return 1
+        # screen_size / world.current_matrix_width
+    end
+
+    def initialize_world
+        World.new(Constants::THEME::BLACKWHITE)
+    end
+
+    def world
+        @world
+    end
+end

data/lib/Engine.rb

@@ -0,0 +1,142 @@
+require 'tty-file'
+require 'date'
+require_relative './Action.rb'
+
+class Engine
+    def initialize(prompt, display)
+        @running = false
+        @prompt = prompt
+        @display = display
+    end
+
+    def run
+        initialize_key_prompt
+        while is_running
+            display.draw
+            show_key_prompts
+        end
+    end
+    
+    def run_v1
+        while is_running
+            display.draw
+            answer = get_answer
+            proccess_answer(answer)
+        end
+    end
+
+    def get_answer
+        prompt.select('', action_map.keys, cycle: true)
+    end
+
+    def proccess_answer(answer)
+        action = action_map[answer]
+        action.call
+    end
+
+    def action_map
+        {
+            'REGENERATE' => Action.new(world.method(:regenerate)),
+            'ZOOM_IN' => Action.new(world.method(:zoom_in)),
+            'ZOOM_OUT' => Action.new(world.method(:zoom_out)),
+            'SCROLL_UP' => Action.new(method(:default_action)),
+            'SCROLL_RIGHT' => Action.new(method(:default_action)),
+            'SCROLL_DOWN' => Action.new(method(:default_action)),
+            'SCROLL_LEFT' => Action.new(method(:default_action)),
+            'QUIT' => Action.new(method(:stop)),
+        }
+    end
+
+    def key_map
+        {
+            'q' => Action.new(method(:stop)),
+            'r' => Action.new(world.method(:regenerate)),
+            'z' => Action.new(world.method(:zoom_in)),
+            'x' => Action.new(world.method(:zoom_out)),
+            'n' => Action.new(method(:name_world)),
+            'e' => Action.new(method(:export_to_txt)),
+            :up => Action.new(world.method(:scroll_up)), # scroll up
+            :down => Action.new(world.method(:scroll_down)), # scroll down
+            :right => Action.new(world.method(:scroll_right)), # scroll right
+            :left => Action.new(world.method(:scroll_left)), # scroll left
+        }
+    end
+
+    def initialize_key_prompt
+        prompt.on(:keypress) { |event| 
+            event_key = event.value
+            event_name = event.key.name
+            key_map[event_key].call if key_map.keys.include?(event_key)
+            key_map[event_name].call if key_map.keys.include?(event_name)
+        }
+    end
+
+    def show_key_prompts
+        prompt.keypress(
+            [
+                "",
+                "-----------------------",
+                "r to generate new world",
+                "arrow keys to explore",
+                "z to zoom in",
+                "x to zoom out",
+                "n to rename this world",
+                "e to save this world in text",
+                "q to quit",
+                ""
+            ].join("\n")
+        )
+    end
+
+    def name_world
+        new_name = prompt.ask('what do people call this world?')
+        world.set_name(new_name)
+    end
+
+    def export_to_txt
+        content = world.render_map_as_text(display.tile_size)
+
+        directory = "exported_worlds"
+        extension = 'txt'
+        file_name = "#{DateTime.now.strftime('%Y_%m_%d__%H%M%S')}__#{world.name}.txt".gsub!(" ","_")
+
+        TTY::File.create_file("#{directory}/#{file_name}", content)
+    end
+
+    def default_action
+        return true
+    end
+
+    def prompt
+        @prompt
+    end
+
+    def display
+        @display
+    end
+
+    def world
+        @display.world
+    end
+
+    def start
+        if is_running
+            throw "engine already running"
+        end
+
+        @running = true
+        run
+    end
+
+    def stop
+        @running = false
+    end
+
+    def is_running
+        @running
+    end
+
+    def is_stopped
+        !is_running
+    end
+end

data/lib/GenerateMatrix.rb

@@ -0,0 +1,54 @@
+require 'perlin_noise'
+require_relative './constants/tile_types.rb'
+
+class GenerateMatrix
+    def two_lands_matrix
+        [
+            [Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:PLAIN]],
+            [Constants::TILE_TYPES[:PLAIN], Constants::TILE_TYPES[:PLAIN], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+            [Constants::TILE_TYPES[:FOREST], Constants::TILE_TYPES[:PLAIN], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+            [Constants::TILE_TYPES[:MOUNTAIN], Constants::TILE_TYPES[:FOREST], Constants::TILE_TYPES[:PLAIN], Constants::TILE_TYPES[:WATER]],
+        ]
+    end
+
+    def water_world_matrix
+        [
+            [Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+            [Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+            [Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+            [Constants::TILE_TYPES[:MOUNTAIN], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER], Constants::TILE_TYPES[:WATER]],
+        ]
+    end
+
+    def perlin_matrix(size)
+        noises = Perlin::Noise.new(2)
+        contrast = Perlin::Curve.contrast(Perlin::Curve::CUBIC, 2)
+        
+        bars = [
+            Constants::TILE_TYPES[:WATER],
+            Constants::TILE_TYPES[:WATER],
+            Constants::TILE_TYPES[:PLAIN],
+            Constants::TILE_TYPES[:FOREST],
+            Constants::TILE_TYPES[:MOUNTAIN],
+        ]
+        bar = lambda { |n|
+          bars[ (bars.length * n).floor ]
+        }
+        
+        perlin_matrix = []
+
+        size.times do |x|
+            row = []
+            size.times do |y|
+                n = noises[x * 0.2, y * 0.2]
+                n = contrast.call n
+            
+                row << bar.call(n)
+            end
+
+            perlin_matrix << row
+        end
+
+        perlin_matrix
+    end
+end

data/lib/GenerateName.rb

@@ -0,0 +1,37 @@
+class GenerateName
+    def world
+        name = [
+            'Earth',
+            'Solace',
+            'Terra',
+            'Nova',
+            'Solida',
+            'Humus',
+            'Viridis',
+            'Orb',
+            'Solo',
+            'Lutum',
+            'Vita',
+        ].sample
+
+        adjective = [
+            '',
+            'Red',
+            'Green',
+            'Blue',
+            'Speckled',
+            'Spotted',
+        ].sample
+
+        suffix = [
+            '',
+            '',
+            '',
+            'One',
+            'Two',
+            'Seven',
+        ].sample
+
+        "#{adjective} #{name} #{suffix}"
+    end
+end

data/lib/World.rb

@@ -0,0 +1,432 @@
+require 'tty-table'
+require 'tty-box'
+require_relative './constants/tile_types.rb'
+require_relative './constants/themes/black_white.rb'
+require_relative './GenerateName.rb'
+require_relative './GenerateMatrix.rb'
+
+
+class Point
+    attr_reader :x, :y, :z
+
+    def initialize(x, y, z)
+        @x = x
+        @y = y
+        @z = z
+    end
+
+    def to_s
+        "#{@x},#{@y},#{@z}"
+    end
+
+end
+
+class World
+    attr_reader :name
+
+    def initialize(theme)
+        @theme = theme
+        @pastel = Pastel.new
+        @max_x = 4
+        @max_y = 4
+        @max_z = 4
+        regenerate
+    end
+
+    def regenerate
+        @name = initialize_name
+        @matrix = initialize_matrix
+        @current_position = Point.new(0, 0, 0)
+
+        @matrix_map = {
+            @current_position.to_s => @matrix
+        }
+    end
+
+    def matrix
+        @matrix_map[@current_position.to_s]
+    end
+
+    def themed_matrix(theme)
+        matrix.map{ |row|
+            row.map{ |tile|
+                theme.colored_tile(@pastel, tile)
+            }
+        }
+    end
+ 
+    def colored_matrix
+        themed_matrix(@theme)
+    end
+
+    def initialize_matrix
+        GenerateMatrix.new.perlin_matrix(4)
+    end
+
+    def initialize_name
+        GenerateName.new.world
+    end
+
+    def set_name(name)
+        @name = name
+    end
+
+    def draw(tile_size)
+        # puts render_framed_map(tile_size)
+        # puts render_framed_table_map(tile_size)
+        # puts render_map(tile_size)
+        puts render_map_with_info(tile_size)
+        # puts render_table_map(tile_size)
+    end
+
+    def render_map_with_info(tile_size)
+        [
+            render_map(tile_size),
+            world_name_display,
+            zoom_level_display,
+            coordinates_display,
+        ].join("\n")
+    end
+
+    def render_matrix(matrix_to_render, theme, tile_size)
+        matrix_to_render.map.with_index { |row, y|
+            row.map.with_index { |tile, x|
+                tile
+            }.join(
+                theme.colored_tile(
+                    @pastel, 
+                    Constants::TILE_TYPES[:NONE]
+                ) * tile_size
+            )
+        }.join("\n" * tile_size)
+    end
+
+    def render_map_as_text(tile_size)
+        theme = Constants::THEME::BLACKWHITE
+        new_matrix = themed_matrix(theme)
+        
+        render_matrix(new_matrix, theme, tile_size)
+    end
+
+    def render_map(tile_size)
+        render_matrix(colored_matrix, @theme, tile_size)
+    end
+
+    def render_table_map(tile_size)
+        table = TTY::Table.new({rows: colored_matrix})
+
+        table.render(
+            :basic,
+            alignments: [:center],
+            padding: tile_size - 1
+        )
+    end
+
+    def render_framed_map(tile_size)
+        map = render_map(tile_size)
+
+        render_frame_around_map(map)
+    end
+
+
+    def render_framed_table_map(tile_size)
+        map = render_table_map(tile_size)
+
+        render_frame_around_map(map)
+    end
+
+    def render_frame_around_map(map)
+        framed_map = TTY::Box.frame(
+            align: :center,
+            title: {
+                bottom_left: coordinates_display,
+                bottom_right: zoom_level_display
+            },
+            border: :thick
+        ) { map }
+
+        framed_map
+    end
+
+    def world_name_display
+        "You are exploring #{@pastel.italic(@name)}"
+    end
+
+    def zoom_level_display
+        "Zoom: #{@current_position.z}"
+    end
+
+    def coordinates_display
+        "x: #{@current_position.x}, y: #{@current_position.y}"
+    end
+
+    def current_matrix_width
+        matrix.length
+    end
+
+    def next_matrix_width
+        (current_matrix_width * 2) - 1
+    end
+
+    def matrix_exists_in_position(position)
+        @matrix_map.keys.include?(position.to_s)
+    end
+
+    def zoom_in
+        new_position = increment_z_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_zoomed_in_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+
+    def zoom_out
+        new_position = decrement_z_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_zoomed_out_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+
+    def scroll_right
+        new_position = increment_x_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_scrolled_right_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+
+    def scroll_left
+        new_position = decrement_x_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_scrolled_left_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+    
+    def scroll_up
+        new_position = increment_y_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_scrolled_up_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+    
+    def scroll_down
+        new_position = decrement_y_level(@current_position)
+        if !matrix_exists_in_position(new_position)
+            generate_new_scrolled_down_map(new_position)
+        end
+
+        @current_position = new_position
+    end
+
+    def increment_x_level(position)
+        add_to_x_level(1, position)
+    end
+
+    def decrement_x_level(position)
+        add_to_x_level(-1, position)
+    end
+
+    def increment_y_level(position)
+        add_to_y_level(1, position)
+    end
+
+    def decrement_y_level(position)
+        add_to_y_level(-1, position)
+    end
+
+    def increment_z_level(position)
+        add_to_z_level(1, position)
+    end
+
+    def decrement_z_level(position)
+        add_to_z_level(-1, position)
+    end
+
+    def add_to_x_level(amount, position)
+        new_x = (position.x + amount).clamp(-@max_x, @max_x)
+        
+        Point.new(
+            new_x,
+            position.y,
+            position.z,
+        )
+    end
+
+    def add_to_y_level(amount, position)
+        new_y = (position.y + amount).clamp(-@max_y, @max_y)
+        
+        Point.new(
+            position.x,
+            new_y,
+            position.z,
+        )
+    end
+
+    def add_to_z_level(amount, position)
+        new_z = (position.z + amount).clamp(0, @max_z)
+        
+        Point.new(
+            position.x,
+            position.y,
+            new_z,
+        )
+    end
+
+    def generate_new_zoomed_in_map(position)
+        zoom_length = next_matrix_width
+        unfilled_new_matrix = []
+        matrix.each_with_index{ |row, i|
+            unfilled_new_matrix << expanded_row(zoom_length, matrix[i])
+            if unfilled_new_matrix.length < zoom_length
+                unfilled_new_matrix << new_row(zoom_length)
+            end
+          }
+        
+        filled_new_matrix = fill_none_tiles(unfilled_new_matrix)
+
+        @matrix_map[position.to_s] = filled_new_matrix
+    end
+    
+    def generate_new_zoomed_out_map(position)
+        new_matrix = []
+        matrix.each_with_index{ |row, i|
+            if i.even?
+                new_row = []
+                matrix[i].each_with_index{ |tile, j|
+                    new_row << tile if j.even?
+                }
+                new_matrix << new_row
+            end
+          }
+        
+        @matrix_map[position.to_s] = new_matrix
+    end
+
+    def generate_new_scrolled_right_map(position)
+        unfilled_new_matrix = matrix.dup.map.with_index{ |row, y|
+            new_row = row.dup
+            new_row.shift
+            new_row << Constants::TILE_TYPES[:NONE]
+            
+            new_row
+        }
+
+        filled_new_matrix = fill_none_tiles(unfilled_new_matrix)
+
+        @matrix_map[position.to_s] = filled_new_matrix
+    end
+    
+    def generate_new_scrolled_left_map(position)
+        unfilled_new_matrix = matrix.dup.map.with_index{ |row, y|
+            new_row = row.dup
+            new_row.pop
+            new_row.unshift(Constants::TILE_TYPES[:NONE])
+            
+            new_row
+        }
+
+        filled_new_matrix = fill_none_tiles(unfilled_new_matrix)
+
+        @matrix_map[position.to_s] = filled_new_matrix
+    end
+
+    def generate_new_scrolled_up_map(position)
+        unfilled_new_matrix = []
+        matrix.dup.map.with_index{ |row, i|
+            unfilled_new_matrix << row.dup if i < (current_matrix_width - 1)
+        }
+
+        unfilled_new_matrix.unshift(new_row(current_matrix_width))
+
+        filled_new_matrix = fill_none_tiles(unfilled_new_matrix)
+
+        @matrix_map[position.to_s] = filled_new_matrix
+    end
+    
+    def generate_new_scrolled_down_map(position)
+        unfilled_new_matrix = []
+        matrix.dup.map.with_index{ |row, i|
+            unfilled_new_matrix << row.dup if i > 0
+        }
+
+        unfilled_new_matrix << new_row(current_matrix_width)
+
+        filled_new_matrix = fill_none_tiles(unfilled_new_matrix)
+
+        @matrix_map[position.to_s] = filled_new_matrix
+    end
+
+    def expanded_row(zoom_length, current_row)
+        new_row = []
+        current_row.each_with_index{ |row, i|
+          new_row << current_row[i]
+          if new_row.length < zoom_length
+            new_row << Constants::TILE_TYPES[:NONE]
+          end
+        }
+        
+        new_row
+    end
+
+    def new_row(zoom_length)
+        return Array.new(zoom_length, Constants::TILE_TYPES[:NONE])
+    end
+
+    def fill_none_tiles(unfilled_matrix)
+        new_matrix = []
+        unfilled_matrix.each_with_index { |row, y|
+            new_row = []
+            row.each_with_index { |tile, x|
+                new_tile = tile
+                if tile == Constants::TILE_TYPES[:NONE]
+                    neighboring_tiles = get_tiles_in_neighboring_positions(x, y, unfilled_matrix);
+                    random_neighbor_tile = neighboring_tiles.select{|tile| ![Constants::TILE_TYPES[:NONE]].include?(tile) }.sample
+                    new_tile = random_neighbor_tile != Constants::TILE_TYPES[:NONE] ? random_neighbor_tile : Constants::TILE_TYPES.sample
+                end
+
+                new_row << new_tile
+            }
+            
+            new_matrix << new_row
+        }
+
+        new_matrix
+    end
+
+    def get_tiles_in_neighboring_positions(x, y, current_matrix)
+        relative_neighboring_positions = [
+            {x: -1, y: 0},
+            {x: 1, y: 0},
+            {x: 0, y: -1},
+            {x: 0, y: 1},
+            {x: -1, y: -1},
+            {x: 1, y: 1},
+            {x: 1, y: -1},
+            {x: -1, y: 1},
+        ]
+      
+        neighboring_tiles = []
+        relative_neighboring_positions.map { |pos|
+            tile = get_tile_at_position(x + pos[:x], y + pos[:y], current_matrix)
+            neighboring_tiles << tile if tile
+        }
+
+        neighboring_tiles
+    end
+
+    def get_tile_at_position(x, y, current_matrix)
+        begin
+            return current_matrix[y][x]
+        rescue => exception
+            return false
+        end
+    end
+end

data/lib/constants/themes/black_white.rb

@@ -0,0 +1,29 @@
+module Constants
+    module THEME
+        module BLACKWHITE
+            def BLACKWHITE.colored_tile(pastel_instance, tile_type)
+                BLACKWHITE.tile_map(pastel_instance)[tile_type][:character]
+            end
+
+            def BLACKWHITE.tile_map(pastel_instance)
+                {
+                    Constants::TILE_TYPES[:NONE] => {
+                        character: ' ',
+                    },
+                    Constants::TILE_TYPES[:WATER] => {
+                        character: ' ',
+                    },
+                    Constants::TILE_TYPES[:FOREST] => {
+                        character: 't',
+                    },
+                    Constants::TILE_TYPES[:MOUNTAIN] => {
+                        character: 'M',
+                    },
+                    Constants::TILE_TYPES[:PLAIN] => {
+                        character: '_',
+                    },
+                }
+            end
+        end
+    end
+end

data/lib/constants/themes/default.rb

@@ -0,0 +1,37 @@
+module Constants
+    module THEME
+        module DEFAULT
+            def DEFAULT.colored_tile(pastel_instance, tile_type)
+                character = DEFAULT.tile_map(pastel_instance)[tile_type][:character]
+                color_method = DEFAULT.tile_map(pastel_instance)[tile_type][:color_method]
+
+                color_method.call(character)
+            end
+
+            def DEFAULT.tile_map(pastel_instance)
+                {
+                    Constants::TILE_TYPES[:NONE] => {
+                        character: ' ',
+                        color_method: pastel_instance.black.method(:on_black),
+                    },
+                    Constants::TILE_TYPES[:WATER] => {
+                        character: '■',
+                        color_method: pastel_instance.blue.method(:on_black),
+                    },
+                    Constants::TILE_TYPES[:FOREST] => {
+                        character: '■',
+                        color_method: pastel_instance.green.method(:on_black),
+                    },
+                    Constants::TILE_TYPES[:MOUNTAIN] => {
+                        character: '■',
+                        color_method: pastel_instance.bright_white.method(:on_black),
+                    },
+                    Constants::TILE_TYPES[:PLAIN] => {
+                        character: '■',
+                        color_method: pastel_instance.bright_yellow.method(:on_black),
+                    },
+                }
+            end
+        end
+    end
+end

data/lib/constants/tile_types.rb

@@ -0,0 +1,13 @@
+module Constants
+    TILE_TYPES = {
+        NONE: 0,
+        FOREST: 1,
+        MOUNTAIN: 2,
+        PLAIN: 3,
+        WATER: 4,
+    }
+
+    def TILE_TYPES.sample
+        TILE_TYPES[TILE_TYPES.keys.select{|key| ![:NONE].include?(key) }.sample]
+    end
+end

data/lib/run.rb

@@ -0,0 +1,3 @@
+require_relative './world_in_your_terminal.rb'
+
+WorldInYourTerminal.new.explore

data/lib/world_in_your_terminal.rb

@@ -0,0 +1,13 @@
+require 'tty-prompt'
+require_relative './Display.rb'
+require_relative './Engine.rb'
+
+class WorldInYourTerminal
+    def explore
+        display = Display.new(40)
+        prompt = TTY::Prompt.new
+
+        engine = Engine.new(prompt, display)
+        engine.start
+    end
+end

metadata

@@ -0,0 +1,165 @@
+--- !ruby/object:Gem::Specification
+name: world_in_your_terminal
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- David Vanderhaar
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-12-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pastel
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: perlin_noise
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.3
+- !ruby/object:Gem::Dependency
+  name: tty-box
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.7.0
+- !ruby/object:Gem::Dependency
+  name: tty-color
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: tty-file
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.10.0
+- !ruby/object:Gem::Dependency
+  name: tty-prompt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.23.1
+- !ruby/object:Gem::Dependency
+  name: tty-screen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.8.1
+- !ruby/object:Gem::Dependency
+  name: tty-table
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: 
+email: d.vanderhaarhunter@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/Action.rb
+- lib/Display.rb
+- lib/Engine.rb
+- lib/GenerateMatrix.rb
+- lib/GenerateName.rb
+- lib/World.rb
+- lib/constants/themes/black_white.rb
+- lib/constants/themes/default.rb
+- lib/constants/tile_types.rb
+- lib/run.rb
+- lib/world_in_your_terminal.rb
+homepage: https://rubygems.org/gems/world_in_your_terminal
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.6
+signing_key: 
+specification_version: 4
+summary: Explore tiny worlds in yor terminal
+test_files: []