maze 1.0.0

data/.gitignore

@@ -0,0 +1,3 @@
+.rvmrc
+*.png
+

data/.rvmrc.example

@@ -0,0 +1 @@
+rvm use 1.9.2

data/Gemfile

@@ -0,0 +1,4 @@
+source :rubygems
+
+gemspec
+

data/Gemfile.lock

@@ -0,0 +1,18 @@
+PATH
+  remote: .
+  specs:
+    mazes (1.0.0)
+      oily_png
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    chunky_png (1.2.5)
+    oily_png (1.0.2)
+      chunky_png (~> 1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  mazes!

data/README.md

@@ -0,0 +1,55 @@
+## Overview
+
+This is a library for generating perfect mazes. The default tessellation is orthogonal. It supports ASCII output.
+
+## Tessellations
+
++ Orthogonal - the standard rectangular grid with passages intersecting at right angles
++ Sigma - composed of interlocking hexagons
+
+## Supported Output Formats
+
++ ASCII
++ PNG
+
+## Algorithms
+
++ Recursive Backtracking
+
+## Examples
+
+Generating an orthogonal maze with default parameters:
+
+    $ ruby -Ilib examples/orthogonal.rb
+
+     _ _ _ _ _ _ _ _ _ _
+    |_     _ _|  _  |   |
+    |  _|_|  _ _| |_ _| |
+    |  _ _ _|_ _    |  _|
+    |_  |  _ _  |_| |_  |
+    |  _|   | |_  |   |_|
+    |_  |_| |  _|_ _| | |
+    | |_ _ _|  _ _  |_  |
+    |  _   _|_  | |_ _ _|
+    |_  |_ _  |_ _  |   |
+    |_ _ _ _|_ _ _ _ _|_|
+    Generated with: examples/orthogonal.rb 10 10 4083063427
+    Written to output file: sample_orthogonal.png
+
+Generating a sigma maze of dimensions 20x5
+
+    $ ruby -Ilib examples/sigma.rb 20 5
+     _   _   _   _   _   _   _   _   _   _
+    / \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_  
+    \_  \_    /  _/  _   _/ \_       _/  _  \ 
+    /  _  \ / \_   _/ \_      \_/ \_/   / \_/ 
+    \_  \_  \ / \_/  _  \_/ \ / \ /  _/ \   \ 
+    / \ / \_/ \   \_  \_   _/   / \_  \_  \ / 
+    \   \   \_  \_   _/ \_/ \_/ \ / \_  \_/ \ 
+    / \_/ \_  \_/ \_/  _   _/  _/  _   _/   / 
+    \_  \   \_/  _/  _/ \_   _/  _  \_/  _/ \ 
+    / \_/ \ /  _  \_  \   \_/ \_/ \_/ \ / \ / 
+    \_   _/  _  \_   _  \_   _   _   _  \_  \ 
+      \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ \_/ 
+    Generated with: examples/sigma.rb 20 5 2645469508
+    Written to output file: sample_sigma.png

data/examples/maze_helper.rb

@@ -0,0 +1,27 @@
+require 'maze'
+
+module MazeHelper
+  ORTHOGONAL = :orthogonal
+  SIGMA      = :sigma
+
+  def self.generate(type, format = :ascii, output_file = nil)
+    width  = (ARGV[0] || 10).to_i
+    height = (ARGV[1] || width).to_i
+    seed   = (ARGV[2] || rand(0xFFFF_FFFF)).to_i
+
+    srand(seed)
+
+    params = { :width => width, :height => height }
+    maze = Maze.const_get(type.capitalize).new(params)
+
+    puts maze.generate.draw(:ascii)
+    unless :ascii == format
+      maze.generate.draw(:png, output_file)
+    end
+
+    puts "Generated with: #{__FILE__} #{width} #{height} #{seed}"
+    puts "Written to output file: #{output_file}" if output_file
+  end
+end
+
+

data/examples/orthogonal.rb

@@ -0,0 +1,3 @@
+require_relative 'maze_helper'
+
+MazeHelper.generate(MazeHelper::ORTHOGONAL, :png, "sample_orthogonal.png")

data/examples/sigma.rb

@@ -0,0 +1,3 @@
+require_relative 'maze_helper'
+
+MazeHelper.generate(MazeHelper::SIGMA, :png, "sample_sigma.png")

data/lib/maze.rb

@@ -0,0 +1,8 @@
+require 'oily_png'
+
+require_relative 'maze/point'
+require_relative 'maze/generic'
+require_relative 'maze/orthogonal'
+require_relative 'maze/sigma'
+require_relative 'maze/version'
+

data/lib/maze/algorithms/recursive_backtracker.rb

@@ -0,0 +1,46 @@
+module Maze
+  module Algorithm
+    class RecursiveBacktracker
+
+      attr_reader :maze
+      
+      def initialize(maze)
+        @maze = maze
+      end
+
+      # Start from any random point in the grid.
+      def run
+        find_path_from(Point.random(maze))
+      end
+
+      # 1. From the current point pick a neighbouring point which has not been
+      #    visited in any direction.
+      # 2. The coordinates of the next point has to be fetched w.r.t the
+      #    direction of traversal. In certain cases like for edge points its
+      #    possible to step out of bounds. We ignore these moves and pick
+      #    another one which will keep us within the grid.
+      # 3. When there is a valid move to a neighbouring point and it has not been
+      #    visited earlier, both points are connected. Now the neighbouring point
+      #    becomes the current point.
+      # 4. We continue recursively connecting paths until we reach certain points
+      #    from which there are no unvisited neighbours, in which case we
+      #    continuously backtrack until we find a neighbouring unvisited point.
+      # 5. The algorithm ends its run when it returns to initial point from where
+      #    it started it's traversal. At this point it's guaranteed to have
+      #     visited all the other points.
+      def find_path_from(current_point)
+        maze.random_directions.each do |direction|
+          next_point = current_point.next(maze, direction)
+
+          if next_point && next_point.unvisited?(maze)
+            maze.connect(current_point, next_point, direction)
+
+            find_path_from(next_point)
+          end
+        end
+      end
+
+    end
+  end
+end
+

data/lib/maze/formatters/ascii.rb

@@ -0,0 +1,47 @@
+module Maze
+  module Formatter
+    module Ascii
+
+      def to_s
+        canvas.map { |line| line.join }.join("\n")
+      end
+
+      alias_method :draw, :to_s
+
+      def canvas_draw
+        maze.height.times do |y|
+          maze.width.times do |x|
+            canvas_update Point.new(x, y)
+          end
+        end
+      end
+
+      def canvas_update(for_point)
+        origin =  calculate_origin(for_point)
+
+        maze.directions.each do |direction|
+          offset = origin + calculate_offset(direction, for_point)
+
+          unless maze.connected?(for_point, direction)
+            canvas[offset.y][offset.x] = select_character(direction)
+          end
+        end
+      end
+
+      private
+
+      def calculate_origin(for_point)
+        raise NotImplementedError, "#{self.class.name} does not implement private method: #{__method__}"
+      end
+
+      def calculate_offset(*args)
+        raise NotImplementedError, "#{self.class.name} does not implement private method: #{__method__}"
+      end
+
+      def select_character(direction)
+        raise NotImplementedError, "#{self.class.name} does not implement private method: #{__method__}"
+      end
+
+    end
+  end
+end

data/lib/maze/formatters/ascii/orthogonal.rb

@@ -0,0 +1,51 @@
+require_relative '../ascii'
+
+module Maze
+  module Formatter
+    module Ascii
+      class Orthogonal
+
+        attr_reader :maze, :canvas
+
+        include Ascii
+
+        def initialize(maze)
+          @maze   = maze
+          @canvas = Array.new(maze.height + 1) do
+            Array.new(maze.width * 2, ' ')
+          end
+
+          canvas_draw
+        end
+
+        private
+
+        def calculate_origin(for_point)
+          for_point.update do |other|
+            other.x *= 2
+            other.y += 1
+          end
+        end
+
+        def calculate_offset(*args)
+          direction = args.first
+
+          case direction
+          when maze.class::N then Point.new(1, -1)
+          when maze.class::W then Point.new(0, 0)
+          when maze.class::S then Point.new(1, 0)
+          when maze.class::E then Point.new(2, 0)
+          end
+        end
+
+        def select_character(for_direction)
+          case for_direction
+          when maze.class::N, maze.class::S then "_"
+          when maze.class::W, maze.class::E then "|"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/maze/formatters/ascii/sigma.rb

@@ -0,0 +1,56 @@
+require_relative '../ascii'
+
+module Maze
+  module Formatter
+    module Ascii
+      class Sigma
+
+        attr_reader :maze, :canvas
+
+        include Ascii
+
+        def initialize(maze)
+          @maze = maze
+          @canvas = Array.new(maze.height * 2 + 2) do
+            Array.new(maze.width * 2 + 2, ' ')
+          end
+
+          canvas_draw
+        end
+
+        private
+
+        def calculate_origin(for_point)
+          for_point.update do |other|
+            other.x *= 2
+            other.y *= 2
+          end
+        end
+
+        def calculate_offset(*args)
+          direction, point = args
+
+          shift_y = maze.shifted_down?(point) ? 1 : 0
+
+          case direction
+          when :north      then Point.new(1, 0 + shift_y)
+          when :north_west then Point.new(0, 1 + shift_y)
+          when :north_east then Point.new(2, 1 + shift_y)
+          when :south_west then Point.new(0, 2 + shift_y)
+          when :south      then Point.new(1, 2 + shift_y)
+          when :south_east then Point.new(2, 2 + shift_y)
+          end
+        end
+
+        def select_character(direction)
+          case direction
+          when :north, :south           then "_"
+          when :north_west, :south_east then "/"
+          when :north_east, :south_west then "\\"
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/maze/formatters/png.rb

@@ -0,0 +1,36 @@
+module Maze
+  module Formatter
+    module Png
+
+      PADDING = 10
+      LENGTH  = 30
+
+      def draw(output_file = nil)
+        lines.each do |end_points|
+          image.line(*end_points, ChunkyPNG::Color::BLACK)
+        end
+        image.save(output_file, :fast_rgb) if output_file
+      end
+
+      private
+
+      def background_colour
+        ChunkyPNG::Color::WHITE
+      end
+
+      def padding_offset
+        PADDING * 2
+      end
+
+      def draw_image
+        maze.height.times do |row|
+          maze.width.times do |column|
+            closed_line_segments(row, column).each do |line_segment|
+              lines << line_segment.map { |point| point.raw }.flatten
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/maze/formatters/png/orthogonal.rb

@@ -0,0 +1,127 @@
+require_relative '../png'
+
+module Maze
+  module Formatter
+    module Png
+      class Orthogonal
+
+        attr_reader :maze, :image, :lines
+
+        include Png
+
+        def initialize(maze)
+          @maze    = maze
+          @image   = ChunkyPNG::Image.new(width, height, background_colour)
+          @lines   = []
+
+          draw_image
+        end
+
+        private
+
+        def width
+          (maze.width * LENGTH + padding_offset).to_i
+        end
+
+        def height
+          (maze.height * LENGTH + padding_offset).to_i
+        end
+
+        def origins
+          @origins ||= compute_origin_points
+        end
+
+        def compute_origin_points
+          points = Array.new(maze.height) { Array.new(maze.width) }
+
+          maze.height.times do |row|
+            maze.width.times do |column|
+              points[row][column] =
+                if 0 == column
+                  first_origin_point(row)
+                else
+                  next_horizontal_origin_point(points[row][column - 1])
+                end
+            end
+          end
+
+          points
+        end
+
+        def first_origin_point(for_row)
+          x = (PADDING + LENGTH * 0.5).to_i
+          y = (PADDING + LENGTH * 0.5 + for_row * LENGTH).to_i
+
+          Point.new(x, y)
+        end
+
+        def next_horizontal_origin_point(previous_point)
+          previous_point.update { |next_origin| next_origin.x += LENGTH }
+        end
+
+        #
+        # Given the origin computes the corner points of the square
+        #
+        #    1                 2
+        #    <--------L-------->
+        #    +--------+--------+
+        #    |      ^ |<-.5 L->|
+        #    |     .5L|        |
+        #    |      V |        |
+        #    +--------+--------+
+        #    |        |O       |
+        #    |        |        |
+        #    |        |        |
+        #    +--------+--------+
+        #    4                 3
+        #
+        # O is Origin
+        #
+        # Faces in clockwise direction:
+        #   * North : 1 - 2
+        #   * East  : 2 - 3
+        #   * South : 3 - 4
+        #   * West  : 4 - 1
+        #
+        def corner_points(origin)
+          faces   = []
+          offsets = [ [-LENGTH, -LENGTH],
+                      [ LENGTH, -LENGTH],
+                      [ LENGTH,  LENGTH],
+                      [-LENGTH,  LENGTH],
+                      [-LENGTH, -LENGTH] ]
+
+          offsets.each do |(offset_x, offset_y)|
+            faces << origin.update do |corner|
+              corner.x += offset_x / 2
+              corner.y += offset_y / 2
+            end
+          end
+          faces
+        end
+
+        #
+        # Group adjacent corner points into pairs
+        #
+        def face_line_segment(origin)
+          corner_points(origin).each_cons(2)
+        end
+
+        def clockwise_directions
+          [ maze.class::N, maze.class::E, maze.class::S, maze.class::W ]
+        end
+
+        def filter_open_faces(line_segments, open = [])
+          line_segments.reject.each_with_index do |segment, i|
+            open.include? clockwise_directions[i]
+          end
+        end
+
+        def closed_line_segments(row, column)
+          filter_open_faces( face_line_segment(origins[row][column]),
+                             maze.grid[row][column] )
+        end
+      end
+    end
+  end
+end

data/lib/maze/formatters/png/sigma.rb

@@ -0,0 +1,137 @@
+require_relative '../png'
+
+module Maze
+  module Formatter
+    module Png
+      class Sigma
+
+        attr_reader :maze, :image, :lines
+
+        include Png
+
+        def initialize(maze)
+          @maze    = maze
+          @image   = ChunkyPNG::Image.new(width, height, background_colour)
+          @lines   = []
+
+          draw_image
+        end
+
+        private
+
+        def width
+          if 0 == maze.width % 2
+            (1.5 * maze.width * LENGTH + 0.5 * LENGTH + padding_offset).to_i
+          else
+            horizontal_units = (1..maze.width).map do |cell_number|
+              0 == cell_number % 2 ? 1 : 2
+            end.inject do |s, x|
+              s + x
+            end
+
+            (horizontal_units * LENGTH +  padding_offset).to_i
+          end
+        end
+
+        def height
+          (maze.height * 2 * LENGTH + LENGTH + padding_offset).to_i
+        end
+
+        def origins
+          @origins ||= compute_origin_points
+        end
+
+        def compute_origin_points
+          points = Array.new(maze.height) { Array.new(maze.width) }
+
+          maze.height.times do |row|
+            maze.width.times do |column|
+              points[row][column] =
+                if 0 == column
+                  first_origin_point(row)
+                else
+                  next_horizontal_origin_point(points[row][column - 1], column)
+                end
+            end
+          end
+
+          points
+        end
+
+        def first_origin_point(row)
+          x = (LENGTH + PADDING).to_i
+          y = (LENGTH + row * 2 * LENGTH + PADDING).to_i
+
+          Point.new(x, y)
+        end
+
+        def next_horizontal_origin_point(previous_point, current_column)
+          previous_point.update do |next_origin|
+            next_origin.x += (1.5 * LENGTH).to_i
+            next_origin.y += (current_column % 2 == 0 ? -LENGTH : LENGTH).to_i
+          end
+        end
+
+        #
+        # Compute corner points traversing in the clock-wise direction
+        #
+        #   0 _____  1
+        #    /     \
+        # 5 /   +   \ 2
+        #   \ origin/
+        #  4 \_____/ 3
+        #
+        # Once the origin is known the points 0 - 5 through can be computed
+        #
+        # Output: [x0, y0, x1, y1, ... , x5, y5, x0, y0]
+        #         Is the closed path of the hexagon
+        #
+        def corner_points(origin)
+          faces   = []
+          offsets = [ [ -LENGTH / 2, -LENGTH ],
+                      [  LENGTH / 2, -LENGTH ],
+                      [  LENGTH,           0 ],
+                      [  LENGTH / 2,  LENGTH ],
+                      [ -LENGTH / 2,  LENGTH ],
+                      [ -LENGTH,           0 ],
+                      [ -LENGTH / 2, -LENGTH ] ]
+
+          offsets.each do |(offset_x, offset_y)|
+            faces << origin.update do |corner|
+              corner.x += offset_x
+              corner.y += offset_y
+            end
+          end
+          faces
+        end
+
+        #
+        # Group adjacent corner points into pairs
+        #
+        def face_line_segment(origin)
+          corner_points(origin).each_cons(2)
+        end
+
+        #
+        # Traces the clockwise directions of the hexagon w.r.t the closed path
+        #
+        def clockwise_directions
+          [ maze.class::N, maze.class::NE, maze.class::SE,
+            maze.class::S, maze.class::SW, maze.class::NW ]
+        end
+
+        def filter_open_faces(line_segments, open = [])
+          line_segments.reject.each_with_index do |segment, i|
+            open.include? clockwise_directions[i]
+          end
+        end
+
+        def closed_line_segments(row, column)
+          filter_open_faces( face_line_segment(origins[row][column]),
+                             maze.grid[row][column] )
+        end
+      end
+    end
+  end
+end
+

data/lib/maze/generic.rb

@@ -0,0 +1,63 @@
+require_relative 'algorithms/recursive_backtracker'
+require_relative 'formatters/ascii'
+
+module Maze
+  class Generic
+
+    attr_reader :width, :height, :grid, :algorithm
+
+    N  = :north
+    S  = :south
+    E  = :east
+    W  = :west
+    NE = :north_east
+    NW = :north_west
+    SE = :south_east
+    SW = :south_west
+
+    def initialize(options)
+      @width     = options[:width]  || 10
+      @height    = options[:height] || 10
+      @grid      = Array.new(height) { Array.new(width) }
+      @algorithm = Algorithm::RecursiveBacktracker.new(self)
+    end
+
+    def generate
+      tap { algorithm.run }
+    end
+
+    def connected?(point, direction)
+      self[point].include?(direction)
+    end
+
+    def connect(current_point, next_point, direction)
+      self[current_point] = direction
+      self[next_point]    = opposite(direction)
+    end
+
+    def []=(point, direction)
+      grid[point.y][point.x] ||= []
+      grid[point.y][point.x] << direction
+    end
+
+    def [](point)
+      grid[point.y][point.x]
+    end
+
+    def draw(format, output_file = nil)
+      format     = format.capitalize.to_s
+      class_name = Formatter.const_get(format).const_get(tessellation)
+
+      unless output_file
+        class_name.new(self).draw
+      else
+        class_name.new(self).draw(output_file)
+      end
+    end
+
+    def tessellation
+      self.class.name[/::(.*)$/, 1]
+    end
+
+  end
+end

data/lib/maze/orthogonal.rb

@@ -0,0 +1,28 @@
+require_relative 'formatters/ascii/orthogonal'
+require_relative 'formatters/png/orthogonal'
+
+module Maze
+  class Orthogonal < Generic
+    OPPOSITE = { N => S, S => N, E => W, W => E }
+
+    def random_directions
+      [N, S, E, W].sort_by { rand }
+    end
+
+    alias_method :directions, :random_directions
+
+    def opposite(direction)
+      OPPOSITE[direction]
+    end
+
+    def calculate_offset_x_axis(*args)
+      distance_x = { N => 0, S => 0, E => 1, W => -1 }
+      distance_x[args.first]
+    end
+
+    def calculate_offset_y_axis(*args)
+      distance_y = { N => -1, S => 1, E => 0, W => 0 }
+      distance_y[args.first]
+    end
+  end
+end

data/lib/maze/point.rb

@@ -0,0 +1,39 @@
+module Maze
+  class Point < Struct.new(:x, :y)
+
+    def self.random(maze)
+      new(rand(maze.width), rand(maze.height))
+    end
+
+    def out_of_bounds?(maze)
+      !(x.between?(0, maze.width  - 1) && y.between?(0, maze.height - 1))
+    end
+
+    def unvisited?(maze)
+      maze[self].nil?
+    end
+
+    def next(maze, direction)
+      next_x = x + maze.calculate_offset_x_axis(direction, self)
+      next_y = y + maze.calculate_offset_y_axis(direction, self)
+      next_point = self.class.new(next_x, next_y)
+
+      next_point.out_of_bounds?(maze) ? nil : next_point
+    end
+
+    def update
+      other = self.dup
+      yield other if block_given?
+      other
+    end
+
+    def +(other)
+      self.class.new(x + other.x, y + other.y)
+    end
+
+    def raw
+      [x, y]
+    end
+  end
+end
+

data/lib/maze/sigma.rb

@@ -0,0 +1,92 @@
+require_relative 'formatters/ascii/sigma'
+require_relative 'formatters/png/sigma'
+
+module Maze
+  class Sigma < Generic
+    OPPOSITE = { N => S, S => N, NE => SW, SW => NE, NW => SE, SE => NW }
+
+    def random_directions
+      [N, S, NE, NW, SE, SW].sort_by { rand }
+    end
+
+    alias_method :directions, :random_directions
+
+    def opposite(direction)
+      OPPOSITE[direction]
+    end
+
+    def calculate_offset_x_axis(*args)
+      direction, point = args
+
+      case direction
+      when N, S
+        0
+      when NW, SW
+        send("noexit_#{direction}?", point) ? 0 : -1
+      when NE, SE
+        send("noexit_#{direction}?", point) ? 0 : 1
+      end
+    end
+
+    def calculate_offset_y_axis(*args)
+      direction, point = args
+
+      case direction
+      when N
+        noexit_north?(point) ? 0 : -1
+      when S
+        noexit_south?(point) ? 0 : 1
+      when NW, NE
+        send("noexit_#{direction}?", point) || shifted_down?(point) ? 0 : -1
+      when SW, SE
+        send("noexit_#{direction}?", point) || shifted_up?(point) ? 0 : 1
+      end
+    end
+
+    def shifted_up?(point)
+      0 == point.x % 2
+    end
+
+    def shifted_down?(point)
+      !shifted_up?(point)
+    end
+
+    private
+
+    def noexit_north?(point)
+      0 == point.y
+    end
+
+    def noexit_south?(point)
+      height - 1 == point.y
+    end
+
+    def noexit_west?(point)
+      0 == point.x
+    end
+
+    def noexit_east?(point)
+      width - 1 == point.y
+    end
+
+    def noexit_north_west?(point)
+      noexit_west?(point) &&
+        (noexit_north?(point) && shifted_up?(point))
+    end
+
+    def noexit_north_east?(point)
+      noexit_east?(point) &&
+        (noexit_north?(point) && shifted_up?(point))
+    end
+
+    def noexit_south_west?(point)
+      noexit_west?(point) &&
+        (noexit_south?(point) && shifted_down?(point))
+    end
+
+    def noexit_south_east?(point)
+      noexit_east?(point) &&
+        (noexit_south?(point) && shifted_down?(point))
+    end
+  end
+end

data/lib/maze/version.rb

@@ -0,0 +1,3 @@
+module Maze
+  VERSION = "1.0.0"
+end

data/maze.gemspec

@@ -0,0 +1,21 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'maze/version'
+
+Gem::Specification.new do |s|
+  s.name        = "maze"
+  s.version     = Maze::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Sherin C"]
+  s.email       = ["sherin.jc@gmail.com"]
+  s.homepage    = "https://github.com/csherin/mazes"
+  s.summary     = "A library for generating mazes."
+  s.description = <<-DESC
+    A library for generating mazes. It supports orthogonal & sigma tessellations
+    in the ASCII or PNG output formats.
+  DESC
+
+  s.add_runtime_dependency "oily_png"
+
+  s.files         = `git ls-files`.split("\n")
+  s.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,80 @@
+--- !ruby/object:Gem::Specification
+name: maze
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Sherin C
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-01-29 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: oily_png
+  requirement: &2157606700 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2157606700
+description: ! "    A library for generating mazes. It supports orthogonal & sigma
+  tessellations\n    in the ASCII or PNG output formats.\n"
+email:
+- sherin.jc@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .rvmrc.example
+- Gemfile
+- Gemfile.lock
+- README.md
+- examples/maze_helper.rb
+- examples/orthogonal.rb
+- examples/sigma.rb
+- lib/maze.rb
+- lib/maze/algorithms/recursive_backtracker.rb
+- lib/maze/formatters/ascii.rb
+- lib/maze/formatters/ascii/orthogonal.rb
+- lib/maze/formatters/ascii/sigma.rb
+- lib/maze/formatters/png.rb
+- lib/maze/formatters/png/orthogonal.rb
+- lib/maze/formatters/png/sigma.rb
+- lib/maze/generic.rb
+- lib/maze/orthogonal.rb
+- lib/maze/point.rb
+- lib/maze/sigma.rb
+- lib/maze/version.rb
+- maze.gemspec
+homepage: https://github.com/csherin/mazes
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.13
+signing_key: 
+specification_version: 3
+summary: A library for generating mazes.
+test_files: []
+has_rdoc: