theseus 1.0.2 → 1.1.0

data/lib/theseus/formatters/png.rb

@@ -117,25 +117,21 @@ module Theseus
       # within the canvas' bounds.
       def line(canvas, p1, p2, color)
         canvas.line(
-          clamp(p1[0].round, 0, canvas.width-1),
-          clamp(p1[1].round, 0, canvas.height-1),
-          clamp(p2[0].round, 0, canvas.width-1),
-          clamp(p2[1].round, 0, canvas.height-1),
+          clamp(p1[0].floor, 0, canvas.width-1),
+          clamp(p1[1].floor, 0, canvas.height-1),
+          clamp(p2[0].floor, 0, canvas.width-1),
+          clamp(p2[1].floor, 0, canvas.height-1),
           color)
       end
 
       # Fills the rectangle defined by the given coordinates with the given color.
       # The coordinates are clamped to lie within the canvas' bounds.
       def fill_rect(canvas, x0, y0, x1, y1, color)
-        x0 = clamp(x0, 0, canvas.width-1)
-        y0 = clamp(y0, 0, canvas.height-1)
-        x1 = clamp(x1, 0, canvas.width-1)
-        y1 = clamp(y1, 0, canvas.height-1)
-        [x0, x1].min.ceil.upto([x0, x1].max.floor) do |x|
-          [y0, y1].min.ceil.upto([y0, y1].max.floor) do |y|
-            canvas.point(x, y, color)
-          end
-        end
+        x0 = clamp(x0, 0, canvas.width-1).floor
+        y0 = clamp(y0, 0, canvas.height-1).floor
+        x1 = clamp(x1, 0, canvas.width-1).floor
+        y1 = clamp(y1, 0, canvas.height-1).floor
+        canvas.rect(x0, y0, x1, y1, color, color)
       end
 
       # Fills the polygon defined by the +points+ array, with the given +color+.
@@ -143,40 +139,12 @@ module Theseus
       # polygon. It is assumed that the polygon is closed. All points are
       # clamped (naively) to lie within the canvas' bounds.
       def fill_poly(canvas, points, color)
-        min_y = 1_000_000
-        max_y = -1_000_000
-        points.each do |x,y|
-          min_y = y if y < min_y
-          max_y = y if y > max_y
+        clamped = points.map do |(x, y)|
+          [ clamp(x.floor, 0, canvas.width - 1),
+            clamp(y.floor, 0, canvas.height - 1) ]
         end
 
-        min_y = clamp(min_y, 0, canvas.height-1)
-        max_y = clamp(max_y, 0, canvas.height-1)
-
-        min_y.floor.upto(max_y.ceil) do |y|
-          nodes = []
-
-          prev = points.last
-          points.each do |point|
-            if point[1] < y && prev[1] >= y || prev[1] < y && point[1] >= y
-              nodes << (point[0] + (y - point[1]).to_f / (prev[1] - point[1]) * (prev[0] - point[0]))
-            end
-            prev = point
-          end
-
-          next if nodes.empty?
-          nodes.sort!
-
-          prev = nil
-          0.step(nodes.length-1, 2) do |a|
-            x1, x2 = nodes[a], nodes[a+1]
-            x1, x2 = x2, x1 if x1 > x2
-            next if x1 < 0 || x2 >= canvas.width
-            x1.ceil.upto(x2.floor) do |x|
-              canvas.point(x, y, color)
-            end
-          end
-        end
+        canvas.polygon(clamped, color, color)
       end
     end
   end

data/lib/theseus/maze.rb

@@ -1,5 +1,6 @@
 require 'theseus/mask'
 require 'theseus/path'
+require 'theseus/algorithms/recursive_backtracker'
 
 module Theseus
   # Theseus::Maze is an abstract class, intended to act solely as a superclass
@@ -12,12 +13,6 @@ module Theseus
   # in the high byte (corresponding to the UNDER bitmask) represent passages
   # that are passing under this cell. (Under/over passages are controlled via the
   # #weave setting, and are not supported by all maze types.)
-  #
-  # Mazes are generated using the recursive backtracking algorithm, which is fast,
-  # quite customizable, easily generalized to a variety of different maze types,
-  # and gives generally good results. On the down side, the current implementation
-  # will not regularly generate very challenging mazes, compared to human-built
-  # mazes of the same size.
   class Maze
     N  = 0x01 # North
     S  = 0x02 # South
@@ -29,15 +24,22 @@ module Theseus
     SE = 0x80 # Southeast
 
     # bitmask identifying directional bits on the primary plane
-    PRIMARY = 0x00FF
+    PRIMARY  = 0x000000FF
 
     # bitmask identifying directional bits under the primary plane
-    UNDER   = 0xFF00
+    UNDER    = 0x0000FF00
+
+    # bits reserved for use by individual algorithm implementations
+    RESERVED = 0xFFFF0000
 
     # The size of the PRIMARY bitmask (e.g. how far to the left the
     # UNDER bitmask is shifted).
     UNDER_SHIFT = 8
 
+    # The algorithm object used to generate this maze. Defaults to
+    # an instance of Algorithms::RecursiveBacktracker.
+    attr_reader :algorithm
+
     # The width of the maze (number of columns).
     #
     # In general, it is safest to use the #row_length method for a particular
@@ -100,14 +102,6 @@ module Theseus
     # to the maze, and generally defaults to the lower-right corner.
     attr_reader :exit
 
-    # The x-coordinate that the generation algorithm will consider next.
-    # This value is meaningless once a maze has been generated.
-    attr_reader :x
-
-    # The y-coordinate that the generation algorithm will consider next.
-    # This value is meaningless once a maze has been generated.
-    attr_reader :y
-
     # A short-hand method for creating a new maze object and causing it to
     # be generated, in one step. Returns the newly generated maze.
     def self.generate(options={})
@@ -123,6 +117,9 @@ module Theseus
     #                maze types count columns and rows differently; you'll
     #                want to see individual maze types for more info.
     # [:height]      The number of rows in the maze.
+    # [:algorithm]   The maze algorithm to use. This should be a class,
+    #                adhering to the interface described by Theseus::Algorithms::Base.
+    #                It defaults to Theseus::Algorithms::RecursiveBacktracker.
     # [:symmetry]    The symmetry to be used when generating the maze. This
     #                defaults to +:none+, but may also be +:x+ (to have the
     #                maze mirrored across the x-axis), +:y+ (to mirror the
@@ -140,12 +137,14 @@ module Theseus
     # [:mask]        An instance of Theseus::Mask (or something that acts
     #                similarly). This can be used to constrain the maze so that
     #                it fills or avoids specific areas, so that shapes and
-    #                patterns can be made.
+    #                patterns can be made. (NOTE: not all algorithms support
+    #                masks.)
     # [:weave]       An integer between 0 and 100 (inclusive) indicating how
     #                frequently passages move under or over other passages.
     #                A 0 means the passages will never move over/under other
     #                passages, while a 100 means they will do so as often
-    #                as possible. (NOTE: not all maze types support weaving.)
+    #                as possible. (NOTE: not all maze types and algorithms
+    #                support weaving.)
     # [:braid]       An integer between 0 and 100 (inclusive) representing
     #                the percentage of dead-ends that should be removed after
     #                the maze has been generated. Dead-ends are removed by
@@ -175,6 +174,8 @@ module Theseus
     #                allowing you to then set the contents of the maze by hand,
     #                using the #[]= method.
     def initialize(options={})
+      @deadends = nil
+
       @width = (options[:width] || 10).to_i
       @height = (options[:height] || 10).to_i
 
@@ -192,14 +193,8 @@ module Theseus
       @entrance = options[:entrance] || default_entrance
       @exit = options[:exit] || default_exit
 
-      loop do
-        @y = rand(@cells.length)
-        @x = rand(@cells[@y].length)
-        break if valid?(@x, @y)
-      end
-
-      @tries = potential_exits_at(@x, @y).sort_by { rand }
-      @stack = []
+      algorithm_class = options[:algorithm] || Algorithms::RecursiveBacktracker
+      @algorithm = algorithm_class.new(self, options)
 
       @generated = options[:prebuilt]
     end
@@ -276,29 +271,17 @@ module Theseus
 
       if @deadends && @deadends.any?
         dead_end = @deadends.pop
-        braid(dead_end[0], dead_end[1])
-        
+        braid_cell(dead_end[0], dead_end[1])
+
         @generated = @deadends.empty?
         return !@generated
       end
 
-      direction = next_direction or return !@generated
-      nx, ny = move(@x, @y, direction)
-
-      apply_move_at(@x, @y, direction)
-
-      # if (nx,ny) is already visited, then we're weaving (moving either over
-      # or under the existing passage).
-      nx, ny, direction = perform_weave(@x, @y, nx, ny, direction) if @cells[ny][nx] != 0
-
-      apply_move_at(nx, ny, opposite(direction))
-
-      @stack.push([@x, @y, @tries])
-      @tries = potential_exits_at(nx, ny).sort_by { rand }
-      @tries.push direction if @tries.include?(direction) unless rand(100) < @randomness
-      @x, @y = nx, ny
-
-      return true
+      if @algorithm.step
+        return true
+      else
+        return finish!
+      end
     end
 
     # Returns +true+ if the maze has been generated.
@@ -349,7 +332,7 @@ module Theseus
     # 1. The coordinates lie within the maze's bounds, and
     # 2. The current mask for the maze does not restrict the location.
     #
-    # If the maze wraps in x, the x coordinate is unconstrained and will be 
+    # If the maze wraps in x, the x coordinate is unconstrained and will be
     # mapped (via modulo) to the bounds. Similarly, if the maze wraps in y,
     # the y coordinate will be unconstrained.
     def valid?(x, y)
@@ -587,7 +570,21 @@ module Theseus
     # Returns the direction of +to+ relative to +from+. +to+ and +from+
     # are both points (2-tuples).
     def relative_direction(from, to)
-      if from[0] < to[0]
+      # first, look for the case where the maze wraps, and from and to
+      # are on opposite sites of the grid.
+      if wrap_x? && from[1] == to[1] && (from[0] == 0 || to[0] == 0) && (from[0] == @width-1 || to[0] == @width-1)
+        if from[0] < to[0]
+          W
+        else
+          E
+        end
+      elsif wrap_y? && from[0] == to[0] && (from[1] == 0 || to[1] == 0) && (from[1] == @height-1 || to[1] == @height-1)
+        if from[1] < to[1]
+          N
+        else
+          S
+        end
+      elsif from[0] < to[0]
         if from[1] < to[1]
           SE
         elsif from[1] > to[1]
@@ -670,6 +667,32 @@ module Theseus
         generated? ? "generated" : "not generated"]
     end
 
+    # Returns +true+ if a weave may be applied at (thru_x,thru_y) when moving
+    # from (from_x,from_y) in +direction+. This will be true if the thru cell
+    # does not already have anything in its UNDER plane, and if the cell
+    # on the far side of thru is valid and blank.
+    #
+    # Subclasses may need to override this method if special interpretations
+    # for +direction+ need to be considered (see SigmaMaze).
+    def weave_allowed?(from_x, from_y, thru_x, thru_y, direction) #:nodoc:
+      nx2, ny2 = move(thru_x, thru_y, direction)
+      return (@cells[thru_y][thru_x] & UNDER == 0) && valid?(nx2, ny2) && @cells[ny2][nx2] == 0
+    end
+
+    def perform_weave(from_x, from_y, to_x, to_y, direction) #:nodoc:
+      if rand(2) == 0 # move under existing passage
+        apply_move_at(to_x, to_y, direction << UNDER_SHIFT)
+        apply_move_at(to_x, to_y, opposite(direction) << UNDER_SHIFT)
+      else # move over existing passage
+        apply_move_at(to_x, to_y, :under)
+        apply_move_at(to_x, to_y, direction)
+        apply_move_at(to_x, to_y, opposite(direction))
+      end
+
+      nx, ny = move(to_x, to_y, direction)
+      [nx, ny, direction]
+    end
+
     private
 
     # Not all maze types support symmetry. If a subclass supports any of the
@@ -698,7 +721,7 @@ module Theseus
       count = ends.length * @braid / 100
       count = 1 if count < 1
 
-      ends.sort_by { rand }[0,count]
+      ends.shuffle[0,count]
     end
 
     # Calculate the default entrance, by looking for the upper-leftmost point.
@@ -723,34 +746,6 @@ module Theseus
       [0, 0] # if every cell is masked, then 0,0 is as good as any!
     end
 
-    # Returns the next direction that ought to be attempted by the recursive
-    # backtracker. This will also handle the backtracking. If there are no
-    # more directions to attempt, and the stack is empty, this will return +nil+.
-    def next_direction #:nodoc:
-      loop do
-        direction = @tries.pop
-        nx, ny = move(@x, @y, direction)
-
-        if valid?(nx, ny) && (@cells[@y][@x] & (direction | (direction << UNDER_SHIFT)) == 0)
-          if @cells[ny][nx] == 0
-            return direction
-          elsif !dead?(@cells[ny][nx]) && @weave > 0 && rand(100) < @weave
-            # see if we can weave over/under the cell at (nx,ny)
-            return direction if weave_allowed?(@x, @y, nx, ny, direction)
-          end
-        end
-
-        while @tries.empty?
-          if @stack.empty?
-            finish!
-            return nil
-          else
-            @x, @y, @tries = @stack.pop
-          end
-        end
-      end
-    end
-
     def move_symmetrically_in_x(x, y, direction) #:nodoc:
       row_width = @cells[y].length
       if direction == :under
@@ -802,6 +797,8 @@ module Theseus
 
       @deadends = deadends_to_braid
       @generated = @deadends.empty?
+
+      return !@generated
     end
 
     # If (x,y) is not a dead-end, this does nothing. Otherwise, it extends the
@@ -809,7 +806,7 @@ module Theseus
     #
     # TODO: look for the direction that results in the longest loop.
     # might be kind of spendy, but worth trying, at least.
-    def braid(x, y) #:nodoc:
+    def braid_cell(x, y) #:nodoc:
       return unless dead?(@cells[y][x])
       tries = potential_exits_at(x, y)
       [opposite(@cells[y][x]), *tries].each do |try|
@@ -825,31 +822,5 @@ module Theseus
       end
     end
 
-    # Returns +true+ if a weave may be applied at (thru_x,thru_y) when moving
-    # from (from_x,from_y) in +direction+. This will be true if the thru cell
-    # does not already have anything in its UNDER plane, and if the cell
-    # on the far side of thru is valid and blank.
-    #
-    # Subclasses may need to override this method if special interpretations
-    # for +direction+ need to be considered (see SigmaMaze).
-    def weave_allowed?(from_x, from_y, thru_x, thru_y, direction) #:nodoc:
-      nx2, ny2 = move(thru_x, thru_y, direction)
-      return (@cells[thru_y][thru_x] & UNDER == 0) && valid?(nx2, ny2) && @cells[ny2][nx2] == 0
-    end
-
-    def perform_weave(from_x, from_y, to_x, to_y, direction) #:nodoc:
-      if rand(2) == 0 # move under existing passage
-        apply_move_at(to_x, to_y, direction << UNDER_SHIFT)
-        apply_move_at(to_x, to_y, opposite(direction) << UNDER_SHIFT)
-      else # move over existing passage
-        apply_move_at(to_x, to_y, :under)
-        apply_move_at(to_x, to_y, direction)
-        apply_move_at(to_x, to_y, opposite(direction))
-      end
-      
-      nx, ny = move(to_x, to_y, direction)
-      [nx, ny, direction]
-    end
-
   end
 end

data/lib/theseus/version.rb

@@ -2,8 +2,8 @@ module Theseus
   # The current version of the Theseus library.
   module Version
     MAJOR = 1
-    MINOR = 0
-    TINY  = 2
+    MINOR = 1
+    TINY  = 0
 
     STRING = [MAJOR, MINOR, TINY].join(".")
   end

data/test/maze_test.rb

@@ -1,7 +1,7 @@
 require 'minitest/autorun'
 require 'theseus'
 
-class MazeTest < MiniTest::Unit::TestCase
+class MazeTest < Minitest::Test
   def test_maze_without_explicit_height_uses_width
     maze = Theseus::OrthogonalMaze.new(width: 10)
     assert_equal 10, maze.width
@@ -140,9 +140,9 @@ class MazeTest < MiniTest::Unit::TestCase
 
   def test_dx_west_should_decrease
     maze = Theseus::OrthogonalMaze.new(width: 10)
-    assert_equal -1, maze.dx(Theseus::Maze::W)
-    assert_equal -1, maze.dx(Theseus::Maze::NW)
-    assert_equal -1, maze.dx(Theseus::Maze::SW)
+    assert_equal(-1, maze.dx(Theseus::Maze::W))
+    assert_equal(-1, maze.dx(Theseus::Maze::NW))
+    assert_equal(-1, maze.dx(Theseus::Maze::SW))
   end
 
   def test_dy_south_should_increase
@@ -154,9 +154,9 @@ class MazeTest < MiniTest::Unit::TestCase
 
   def test_dy_north_should_decrease
     maze = Theseus::OrthogonalMaze.new(width: 10)
-    assert_equal -1, maze.dy(Theseus::Maze::N)
-    assert_equal -1, maze.dy(Theseus::Maze::NE)
-    assert_equal -1, maze.dy(Theseus::Maze::NW)
+    assert_equal(-1, maze.dy(Theseus::Maze::N))
+    assert_equal(-1, maze.dy(Theseus::Maze::NE))
+    assert_equal(-1, maze.dy(Theseus::Maze::NW))
   end
 
   def test_opposite_should_report_inverse_direction
@@ -174,7 +174,7 @@ class MazeTest < MiniTest::Unit::TestCase
   def test_step_should_populate_current_cell_and_next_cell
     maze = Theseus::OrthogonalMaze.new(width: 10)
 
-    cx, cy = maze.x, maze.y
+    cx, cy = maze.algorithm.x, maze.algorithm.y
     assert cx >= 0 && cx < maze.width
     assert cy >= 0 && cy < maze.height
     assert_equal 0, maze[cx, cy]
@@ -186,7 +186,7 @@ class MazeTest < MiniTest::Unit::TestCase
 
     nx, ny = maze.move(cx, cy, direction)
     refute_equal [nx, ny], [cx, cy]
-    assert_equal [nx, ny], [maze.x, maze.y]
+    assert_equal [nx, ny], [maze.algorithm.x, maze.algorithm.y]
 
     assert_equal maze.opposite(direction), maze[nx, ny]
   end

metadata

@@ -1,58 +1,58 @@
---- !ruby/object:Gem::Specification 
+--- !ruby/object:Gem::Specification
 name: theseus
-version: !ruby/object:Gem::Version 
-  prerelease: false
-  segments: 
-  - 1
-  - 0
-  - 2
-  version: 1.0.2
+version: !ruby/object:Gem::Version
+  version: 1.1.0
 platform: ruby
-authors: 
+authors:
 - Jamis Buck
 autorequire: 
 bindir: bin
 cert_chain: []
-
-date: 2010-12-20 00:00:00 -07:00
-default_executable: 
-dependencies: 
-- !ruby/object:Gem::Dependency 
+date: 2018-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
   name: chunky_png
-  prerelease: false
-  requirement: &id001 !ruby/object:Gem::Requirement 
-    requirements: 
-    - - ~>
-      - !ruby/object:Gem::Version 
-        segments: 
-        - 0
-        - 12
-        - 0
-        version: 0.12.0
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
   type: :runtime
-  version_requirements: *id001
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
 description: Theseus is a library for building random mazes.
-email: jamis@jamisbuck.org
-executables: 
+email:
+- jamis@jamisbuck.org
+executables:
 - theseus
 extensions: []
-
 extra_rdoc_files: []
-
-files: 
+files:
 - README.rdoc
 - Rakefile
+- bin/theseus
+- examples/a-star-search.rb
+- lib/theseus.rb
+- lib/theseus/algorithms/base.rb
+- lib/theseus/algorithms/kruskal.rb
+- lib/theseus/algorithms/prim.rb
+- lib/theseus/algorithms/recursive_backtracker.rb
+- lib/theseus/cli.rb
 - lib/theseus/delta_maze.rb
+- lib/theseus/formatters/ascii.rb
 - lib/theseus/formatters/ascii/delta.rb
 - lib/theseus/formatters/ascii/orthogonal.rb
 - lib/theseus/formatters/ascii/sigma.rb
 - lib/theseus/formatters/ascii/upsilon.rb
-- lib/theseus/formatters/ascii.rb
+- lib/theseus/formatters/png.rb
 - lib/theseus/formatters/png/delta.rb
 - lib/theseus/formatters/png/orthogonal.rb
 - lib/theseus/formatters/png/sigma.rb
 - lib/theseus/formatters/png/upsilon.rb
-- lib/theseus/formatters/png.rb
 - lib/theseus/mask.rb
 - lib/theseus/maze.rb
 - lib/theseus/orthogonal_maze.rb
@@ -63,39 +63,29 @@ files:
 - lib/theseus/solvers/base.rb
 - lib/theseus/upsilon_maze.rb
 - lib/theseus/version.rb
-- lib/theseus.rb
-- examples/a-star-search.rb
-- bin/theseus
 - test/maze_test.rb
-has_rdoc: true
-homepage: http://github.com/jamis/theseus
-licenses: []
-
+homepage: https://github.com/jamis/theseus
+licenses:
+- MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
-
-require_paths: 
+require_paths:
 - lib
-required_ruby_version: !ruby/object:Gem::Requirement 
-  requirements: 
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-required_rubygems_version: !ruby/object:Gem::Requirement 
-  requirements: 
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
   - - ">="
-    - !ruby/object:Gem::Version 
-      segments: 
-      - 0
-      version: "0"
-requirements: 
-- Ruby 1.9
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
 rubyforge_project: 
-rubygems_version: 1.3.6
+rubygems_version: 2.6.11
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Maze generator for Ruby
 test_files: []
-