knossos 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: af6ea5967ce320c641b22ccc126afd464d79546ab900100a35e2399958c2abbc
+  data.tar.gz: e08581a4b99d792c5187ea79d4d4a685e0837657aa9c45626e7dc6980f8040fc
+SHA512:
+  metadata.gz: a4a1164a115ea289648b802486cacae6b1d839f915f81f522d7e429b09c3ed0a82951591ce49990897d88d95f5a98e1b380c3761702596c44c13044c600aa9ab
+  data.tar.gz: 412bedde05650f80014e68342dc6c56d72bb07f891d098cb71d28658ef1a5827dad8f11b4e9dd39bb33acd5cd23db9365b0ab2e40191d1e4095225c12d01c667

data/CHANGELOG.md

@@ -0,0 +1,41 @@
+# Changelog
+All notable changes to this project will be documented in this file.
+
+This project uses [Semantic Versioning][sv].
+
+## [Unreleased][new]
+
+## [0.1.0][0.1.0] — 2020-01-07
+### Added
+- Create an `Algorithm` module to hold the maze generators.
+- Create a `Renderer` module to hold the methods that produce graphical
+representations of a maze.
+- Create `Renderer::Text` to produce ASCII text representations.
+### Changed
+- Move `AldousBroder` to the `Algorithm` module
+- Move `BinaryTree` to the `Algorithm` module
+- Move `RecursiveBacktracker` to the `Algorithm` module
+- Move `Sidewinder` to the `Algorithm` module
+- Move `Wilsons` to the `Algorithm` module
+- Move and rename `Display` to `Renderer::Image`
+- Rename `Display.to_png` to `Image.render`
+### Fixed
+- Correctly scope private class methods in `Sidewinder`
+- Algorithms now uniformly require a `grid:` keyword argument to `.carve`
+### Removed
+- `Grid` no longer has a custom `to_s` method to produce a graphical maze.
+Use `Renderer::Text.render` instead.
+
+## [0.0.0][0.0.0] — 2020-01-02
+### Added
+- Restructure the project as a Ruby gem.
+
+---
+_This file is composed with [GitHub Flavored Markdown][gfm]._
+
+[gfm]: https://github.github.com/gfm/
+[sv]: https://semver.org
+
+[new]: https://github.com/petejh/knossos/compare/HEAD..v0.1.0
+[0.1.0]: https://github.com/petejh/knossos/releases/tag/v0.1.0
+[0.0.0]: https://github.com/petejh/knossos/releases/tag/v0.0.0

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Peter J. Hinckley
+
+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,74 @@
+# Knossos
+A library for generating mazes inspired by [_Mazes for Programmers_][mfp] by
+Jamis Buck and [_Think Labyrinth!_][tlab] by Walter Pullen.
+
+## Installation
+Add the following line to your application's Gemfile:
+```bash
+gem 'knossos'
+```
+Or install the library globally with:
+```bash
+~$ gem install knossos
+```
+
+## Usage
+```ruby
+#!/usr/bin/env ruby
+
+require 'knossos'
+
+grid = Knossos::Grid.new({rows: 5, columns: 5})
+Algorithm::BinaryTree.carve(grid: grid)
+
+text_renderer = Renderer::Text.new
+puts text_renderer.render(grid: grid)
+
+image_renderer = Renderer::Image.new(grid)
+png = image_renderer.render
+png.save("maze.png")
+```
+
+## Contributing
+Bug reports and pull requests are welcome on [GitHub][orig]. Knossos provides
+a safe, welcoming space for collaboration. Everyone contributing to our
+project—including the codebase, issue trackers, chat, email, social media and
+the like—is expected to uphold our [Code of Conduct][coc].
+
+### Setting Up
+[Fork the project][fork] on GitHub and make a local clone. Install dependencies,
+and run the tests:
+```bash
+~/knossos$ bin/setup
+~/knossos$ bundle exec rake rspec
+```
+
+### Running the Code
+You can experiment with the code interactively using:
+```bash
+~/knossos$ bin/console
+```
+
+### Publishing
+To release a new version of the library, first increment the version number in
+`lib/knossos/version.rb` following [Semantic Versioning][semv] policy, and
+update `CHANGELOG.md`. Commit your work, and finally, run:
+```bash
+# Create a git tag, push commits and tags, and publish to rubygems.org
+~/knossos$ bundle exec rake release
+```
+
+## License
+This gem is available as open source under the terms of the [MIT License][mit].
+
+---
+_This file is composed with [GitHub Flavored Markdown][gfm]._
+
+[coc]:  https://github.com/petejh/knossos/blob/master/CODE_OF_CONDUCT.md
+[fork]: https://help.github.co://help.github.com/en/github/getting-started-with-github/fork-a-repo
+[gfm]:  https://github.github.com/gfm/
+[orig]: https://github.com/petejh/knossos
+[mfp]:  https://pragprog.com/book/jbmaze/mazes-for-programmers
+[mit]:  https://github.com/petejh/knossos/blob/master/LICENSE.txt
+[semv]: https://semver.org
+[tlab]: http://astrolog.org/labyrnth.htm

data/lib/knossos.rb

@@ -0,0 +1,9 @@
+require 'knossos/algorithm'
+require 'knossos/cell'
+require 'knossos/error'
+require 'knossos/grid'
+require 'knossos/renderer'
+require 'knossos/version'
+
+module Knossos
+end

data/lib/knossos/algorithm.rb

@@ -0,0 +1,10 @@
+require_relative 'algorithm/aldous_broder'
+require_relative 'algorithm/binary_tree'
+require_relative 'algorithm/recursive_backtracker'
+require_relative 'algorithm/sidewinder'
+require_relative 'algorithm/wilsons'
+
+module Knossos
+  module Algorithm
+  end
+end

data/lib/knossos/algorithm/aldous_broder.rb

@@ -0,0 +1,21 @@
+module Algorithm
+  class AldousBroder
+    def self.carve(grid:)
+      cell = grid.random_cell
+      unvisited = grid.cell_count - 1
+
+      while unvisited > 0
+        neighbor = grid.neighborhood(cell).sample
+
+        if neighbor.links.empty?
+          grid.build_passage(cell, neighbor)
+          unvisited -= 1
+        end
+
+        cell = neighbor
+      end
+
+      grid
+    end
+  end
+end

data/lib/knossos/algorithm/binary_tree.rb

@@ -0,0 +1,20 @@
+module Algorithm
+  class BinaryTree
+    def self.carve(grid:)
+      grid.each_cell do |cell|
+        neighbors = []
+
+        north = grid.north(cell)
+        neighbors << north if north
+
+        east = grid.east(cell)
+        neighbors << east if east
+
+        neighbor = neighbors.sample
+        grid.build_passage(cell, neighbor) if neighbor
+      end
+
+      grid
+    end
+  end
+end

data/lib/knossos/algorithm/recursive_backtracker.rb

@@ -0,0 +1,23 @@
+module Algorithm
+  class RecursiveBacktracker
+    def self.carve(grid:, start_at: grid.random_cell)
+      stack = []
+      stack.push start_at
+
+      while stack.any?
+        current = stack.last
+        neighbors = grid.neighborhood(current).select { |n| n.links.empty? }
+
+        if neighbors.empty?
+          stack.pop
+        else
+          neighbor = neighbors.sample
+          grid.build_passage(current, neighbor)
+          stack.push(neighbor)
+        end
+      end
+
+      grid
+    end
+  end
+end

data/lib/knossos/algorithm/sidewinder.rb

@@ -0,0 +1,42 @@
+module Algorithm
+  class Sidewinder
+    def self.carve(grid:)
+      grid.each_row do |row|
+        run = []
+        row.each do |cell|
+          run << cell
+
+          if close_out_run?(grid, cell)
+            member = run.sample
+
+            north = grid.north(member)
+            grid.build_passage(member, north) if north
+
+            run.clear
+          else
+            east = grid.east(cell)
+            grid.build_passage(cell, east)
+          end
+        end
+      end
+
+      grid
+    end
+
+    class << self
+      private
+
+      def close_out_run?(grid, cell)
+        at_east_border?(grid, cell) || (!at_north_border?(grid, cell) && rand(2) == 0)
+      end
+
+      def at_east_border?(grid, cell)
+        grid.east(cell).nil?
+      end
+
+      def at_north_border?(grid, cell)
+        grid.north(cell).nil?
+      end
+    end
+  end
+end

data/lib/knossos/algorithm/wilsons.rb

@@ -0,0 +1,32 @@
+module Algorithm
+  class Wilsons
+    def self.carve(grid:)
+      unvisited = []
+      grid.each_cell { |cell| unvisited << cell }
+
+      unvisited.delete(unvisited.sample)
+      while unvisited.any?
+        cell = unvisited.sample
+        path = [cell]
+
+        while unvisited.include?(cell)
+          cell = grid.neighborhood(cell).sample
+
+          position = path.index(cell)
+          if position
+            path = path[0..position]
+          else
+            path << cell
+          end
+        end
+
+        0.upto(path.length - 2) do |index|
+          grid.build_passage(path[index], path[index + 1])
+          unvisited.delete(path[index])
+        end
+      end
+
+      grid
+    end
+  end
+end

data/lib/knossos/cell.rb

@@ -0,0 +1,30 @@
+module Knossos
+  class Cell
+    attr_reader :row, :column, :links
+    attr_accessor :contents
+
+    def initialize(args = {})
+      args = defaults.merge(args)
+
+      @row = args[:row]
+      @column = args[:column]
+      @contents = args[:contents]
+
+      @links = []
+    end
+
+    def link_to(cell)
+      @links << cell
+    end
+
+    def linked?(cell)
+      @links.include? cell
+    end
+
+    private
+
+    def defaults
+      {}
+    end
+  end
+end

data/lib/knossos/error.rb

@@ -0,0 +1,3 @@
+module Knossos
+  class Error < StandardError; end
+end

data/lib/knossos/grid.rb

@@ -0,0 +1,96 @@
+module Knossos
+  class Grid
+    attr_reader :rows, :columns
+
+    def initialize(args = {})
+      args = defaults.merge(args)
+
+      @rows = args[:rows]
+      @columns = args[:columns]
+
+      @grid = assemble_grid
+    end
+
+    def [](row, column)
+      return nil unless row_is_valid?(row)
+      return nil unless column_is_valid?(row, column)
+
+      grid[row][column]
+    end
+
+    def each_row
+      grid.each_with_index { |cells, row| yield(cells, row) }
+    end
+
+    def each_cell
+      each_row do |cells, row|
+        cells.each_with_index { |cell, column| yield(cell, row, column) }
+      end
+    end
+
+    def random_cell
+      row = rand(rows)
+      column = rand(columns_for(row))
+
+      self[row, column]
+    end
+
+    def cell_count
+      grid.reduce(0) { |acc, e| acc += e.count }
+    end
+
+    def north(cell)
+      self[cell.row - 1, cell.column]
+    end
+
+    def east(cell)
+      self[cell.row, cell.column + 1]
+    end
+
+    def south(cell)
+      self[cell.row + 1, cell.column]
+    end
+
+    def west(cell)
+      self[cell.row, cell.column - 1]
+    end
+
+    def neighborhood(cell)
+      [:north, :east, :south, :west].map { |dir| self.send(dir, cell) }.compact
+    end
+
+    def build_passage(cell, other)
+      cell.link_to(other)
+      other.link_to(cell)
+    end
+
+    private
+    attr_accessor :grid
+
+    def defaults
+      { :rows => 10,
+        :columns => 10
+      }
+    end
+
+    def assemble_grid
+      Array.new(@rows) do |row|
+        Array.new(@columns) do |column|
+          Cell.new({ :row => row, :column => column })
+        end
+      end
+    end
+
+    def row_is_valid?(row)
+      row.between?(0, @rows - 1)
+    end
+
+    def column_is_valid?(row, column)
+      column.between?(0, columns_for(row) - 1)
+    end
+
+    def columns_for(row)
+      grid[row].count
+    end
+  end
+end

data/lib/knossos/renderer.rb

@@ -0,0 +1,8 @@
+require_relative 'renderer/image'
+require_relative 'renderer/png_adapter'
+require_relative 'renderer/text'
+
+module Knossos
+  module Renderer
+  end
+end

data/lib/knossos/renderer/image.rb

@@ -0,0 +1,56 @@
+module Renderer
+  class Image
+    def initialize(grid, **options)
+      options = defaults.merge(options)
+
+      @grid = grid
+      @cell_size = options[:cell_size]
+      @background_color = options[:background_color]
+      @wall_color = options[:wall_color]
+
+      @image = create_canvas
+    end
+
+    def render
+      grid.each_cell do |cell, row, column|
+        x1, y1, x2, y2 = coordinates_for(row, column)
+
+        image.line(x1, y1, x2, y1, wall_color) unless grid.north(cell)
+        image.line(x1, y1, x1, y2, wall_color) unless grid.west(cell)
+
+        image.line(x2, y1, x2, y2, wall_color) unless cell.linked?(grid.east(cell))
+        image.line(x1, y2, x2, y2, wall_color) unless cell.linked?(grid.south(cell))
+      end
+
+      image
+    end
+
+    private
+    attr_reader :grid, :cell_size, :background_color, :wall_color
+    attr_accessor :image
+
+    def defaults
+      { cell_size: 10,
+        background_color: PNGAdapter::Color::WHITE,
+        wall_color: PNGAdapter::Color::BLACK
+      }
+    end
+
+    def create_canvas
+      width = grid.columns * cell_size
+      height = grid.rows * cell_size
+
+      PNGAdapter::Image.new(width + 1, height + 1, background_color)
+    end
+
+    def coordinates_for(row, column)
+      x1 = cell_size * column
+      y1 = cell_size * row
+
+      x2 = cell_size * (column + 1)
+      y2 = cell_size * (row + 1)
+
+      [x1, y1, x2, y2]
+    end
+  end
+end

data/lib/knossos/renderer/png_adapter.rb

@@ -0,0 +1,27 @@
+require 'chunky_png'
+
+module Renderer
+  module PNGAdapter
+    class Image
+      def initialize(width, height, color)
+        @image = ChunkyPNG::Image.new(width, height, color)
+      end
+
+      def line(x0, y0, x1, y1, color)
+        image.line(x0, y0, x1, y1, color)
+      end
+
+      def save(filename)
+        image.save(filename)
+      end
+
+      private
+      attr_accessor :image
+    end
+
+    module Color
+      WHITE = ChunkyPNG::Color::WHITE
+      BLACK = ChunkyPNG::Color::BLACK
+    end
+  end
+end

data/lib/knossos/renderer/text.rb

@@ -0,0 +1,32 @@
+module Renderer
+  class Text
+    def initialize
+      # nothing to do
+    end
+
+    def render(grid:)
+      output = "+" + "---+" * grid.columns + "\n"
+
+      grid.each_row do |row|
+        body = "|"
+        bottom = "+"
+
+        row.each do |cell|
+          east = grid.east(cell)
+          east_border = cell.linked?(east) ? " " : "|"
+
+          south = grid.south(cell)
+          south_border = cell.linked?(south) ? "   " : "---"
+
+          body << "   " << east_border
+          bottom << south_border << "+"
+        end
+
+        output << body << "\n"
+        output << bottom << "\n"
+      end
+
+      output
+    end
+  end
+end

data/lib/knossos/version.rb

@@ -0,0 +1,3 @@
+module Knossos
+  VERSION = '0.1.0'
+end

metadata

@@ -0,0 +1,122 @@
+--- !ruby/object:Gem::Specification
+name: knossos
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Peter J. Hinckley
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2020-01-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chunky_png
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: A library for generating mazes inspired by "Mazes for Programmers" by
+  Jamis Buck and "Think Labyrinth!" by Walter Pullen.
+email:
+- petejh.code@q.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE.txt
+- README.md
+- lib/knossos.rb
+- lib/knossos/algorithm.rb
+- lib/knossos/algorithm/aldous_broder.rb
+- lib/knossos/algorithm/binary_tree.rb
+- lib/knossos/algorithm/recursive_backtracker.rb
+- lib/knossos/algorithm/sidewinder.rb
+- lib/knossos/algorithm/wilsons.rb
+- lib/knossos/cell.rb
+- lib/knossos/error.rb
+- lib/knossos/grid.rb
+- lib/knossos/renderer.rb
+- lib/knossos/renderer/image.rb
+- lib/knossos/renderer/png_adapter.rb
+- lib/knossos/renderer/text.rb
+- lib/knossos/version.rb
+homepage: https://github.com/petejh/knossos
+licenses:
+- MIT
+metadata:
+  homepage_uri: https://github.com/petejh/knossos
+  source_code_uri: https://github.com/petejh/knossos
+  changelog_uri: https://github.com/petejh/knossos/CHANGELOG.md
+  bug_tracker_uri: https://github.com/petejh/knossos/issues
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: A library for generating mazes.
+test_files: []