theseus 1.0.2 → 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7cab672f9d3d677b4e11d56540a0050cc6f1f26f
+  data.tar.gz: 29094f4def583c3371b6c47ce93370012256def8
+SHA512:
+  metadata.gz: 731e708c8c4fadd6f0f934bb42ee65aea8b686fb45ecbe437fa4023550ae6693c5d6579806dcf3b37c7949fecb5082023607a0d3ed5138a2dae8d15a020791a0
+  data.tar.gz: 307256f22616f13b05e4763657b96fe638af856c2bfa08beba59f5509059270a4837a80494395ee61e9102f4e0b2ce62e42f7271985a7577ec3c2d741276e0e9

data/Rakefile

@@ -1,10 +1,7 @@
 require 'rake'
-require 'rake/gempackagetask'
-require 'rake/rdoctask'
+require 'rdoc/task'
 require 'rake/testtask'
 
-require './lib/theseus/version'
-
 task :default => :test
 
 Rake::TestTask.new do |t|
@@ -12,26 +9,6 @@ Rake::TestTask.new do |t|
   t.verbose = true
 end
 
-spec = Gem::Specification.new do |s|
-  s.platform = Gem::Platform::RUBY
-  s.summary = "Maze generator for Ruby"
-  s.name = 'theseus'
-  s.version = Theseus::Version::STRING
-  s.files = FileList["README.rdoc", "Rakefile", "lib/**/*.rb", "examples/**/*.rb", "bin/*", "test/**/*.rb"].to_a
-  s.executables << "theseus"
-  s.add_dependency "chunky_png", "~> 0.12.0"
-  s.requirements << "Ruby 1.9"
-  s.description = "Theseus is a library for building random mazes."
-  s.author = "Jamis Buck"
-  s.email = "jamis@jamisbuck.org"
-  s.homepage = "http://github.com/jamis/theseus"
-end
-
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_zip = true
-  pkg.need_tar = true
-end
-
 Rake::RDocTask.new do |rd|
   rd.main = "README.rdoc"
   rd.rdoc_files.include("README.rdoc", "lib/**/*.rb")

data/bin/theseus

@@ -1,262 +1,5 @@
 #!/usr/bin/env ruby
 
-require 'optparse'
-require 'theseus'
-require 'theseus/formatters/png'
+require 'theseus/cli'
 
-type_map = {
-  "ortho"   => Theseus::OrthogonalMaze,
-  "delta"   => Theseus::DeltaMaze,
-  "sigma"   => Theseus::SigmaMaze,
-  "upsilon" => Theseus::UpsilonMaze
-}
-
-animate = false
-output = "maze"
-sparse = 0
-unicursal = false
-type = "ortho"
-format = :ascii
-
-png_opts = Theseus::Formatters::PNG::DEFAULTS.dup
-maze_opts = { mask: nil, width: nil, height: nil,
-  randomness: 50, weave: 0, symmetry: :none, braid: 0, wrap: :none,
-  entrance: nil, exit: nil }
-
-OptionParser.new do |opts|
-  opts.separator ""
-  opts.separator "Required options:"
-
-  opts.on("-w", "--width N", Integer, "width of the maze (default 20, or mask width)") do |w|
-    maze_opts[:width] = w
-  end
-
-  opts.on("-H", "--height N", Integer, "height of the maze (default 20 or mask height)") do |h|
-    maze_opts[:height] = h
-  end
-
-  opts.on("-m", "--mask FILE", "png file to use as mask") do |m|
-    case m
-    when /^triangle:(\d+)$/ then maze_opts[:mask] = Theseus::TriangleMask.new($1.to_i)
-    else maze_opts[:mask] = Theseus::Mask.from_png(m)
-    end
-  end
-
-  opts.separator ""
-  opts.separator "Output options:"
-
-  opts.on("-a", "--[no-]animate", "emit frames for each step") do |v|
-    animate = v
-  end
-
-  opts.on("-o", "--output FILE", "where to save the file(s) (for png only)") do |f|
-    output = f
-  end
-
-  opts.on("-f", "--format FMT", "png, ascii (default #{format})") do |f|
-    format = f.to_sym
-  end
-
-  opts.on("-V", "--solve [METHOD]", "whether to display the solution of the maze.", "METHOD is either `backtracker' (the default) or `astar'") do |s|
-    png_opts[:solution] = (s || :backtracker).to_sym
-  end
-
-  opts.separator ""
-  opts.separator "Maze options:"
-
-  opts.on("-s", "--seed N", Integer, "random seed to use") do |s|
-    srand(s)
-  end
-
-  opts.on("-t", "--type TYPE", "#{type_map.keys.sort.join(",")} (default: #{type})") do |t|
-    type = t
-  end
-
-  opts.on("-u", "--[no-]unicursal", "generate a unicursal maze (results in 2x size)") do |u|
-    unicursal = u
-  end
-
-  opts.on("-y", "--symmetry TYPE", "one of none,x,y,xy,radial (default is '#{maze_opts[:symmetry]}')") do |s|
-    maze_opts[:symmetry] = s.to_sym
-  end
-
-  opts.on("-e", "--weave N", Integer, "0-100, chance of a passage to go over/under another (default #{maze_opts[:weave]})") do |v|
-    maze_opts[:weave] = v
-  end
-
-  opts.on("-r", "--random N", Integer, "0-100, randomness of maze (default #{maze_opts[:randomness]})") do |r|
-    maze_opts[:randomness] = r
-  end
-
-  opts.on("-S", "--sparse N", Integer, "how sparse to make the maze (default #{sparse})") do |s|
-    sparse = s
-  end
-
-  opts.on("-d", "--braid N", Integer, "0-100, percentage of deadends to remove (default #{maze_opts[:braid]})") do |b|
-    maze_opts[:braid] = b
-  end
-
-  opts.on("-R", "--wrap axis", "none,x,y,xy (default #{maze_opts[:wrap]})") do |w|
-    maze_opts[:wrap] = w.to_sym
-  end
-
-  opts.on("-E", "--enter [X,Y]", "the entrance of the maze (default -1,0)") do |s|
-    maze_opts[:entrance] = s.split(/,/).map { |v| v.to_i }
-  end
-
-  opts.on("-X", "--exit [X,Y]", "the exit of the maze (default width,height-1)") do |s|
-    maze_opts[:exit] = s.split(/,/).map { |v| v.to_i }
-  end
-
-  opts.separator ""
-  opts.separator "Formatting options:"
-
-  opts.on("-B", "--background COLOR", "rgba hex background color for maze (default %08X)" % png_opts[:background]) do |c|
-    png_opts[:background] = c
-  end
-
-  opts.on("-C", "--cellcolor COLOR", "rgba hex cell color for maze (default %08X)" % png_opts[:cell_color]) do |c|
-    png_opts[:cell_color] = c
-  end
-
-  opts.on("-L", "--wallcolor COLOR", "rgba hex wall color for maze (default %08X)" % png_opts[:wall_color]) do |c|
-    png_opts[:wall_color] = c
-  end
-
-  opts.on("-U", "--solutioncolor COLOR", "rgba hex color for the answer path (default %08X)" % png_opts[:solution_color]) do |c|
-    png_opts[:solution_color] = c
-  end
-
-  opts.on("-c", "--cell N", Integer, "size of each cell (default #{png_opts[:cell_size]})") do |c|
-    png_opts[:cell_size] = c
-  end
-
-  opts.on("-b", "--border N", Integer, "border padding around outside (default #{png_opts[:outer_padding]})") do |c|
-    png_opts[:outer_padding] = c
-  end
-
-  opts.on("-p", "--padding N", Integer, "padding around cell (default #{png_opts[:cell_padding]})") do |c|
-    png_opts[:cell_padding] = c
-  end
-
-  opts.on("-W", "--wall N", Integer, "thickness of walls (default #{png_opts[:wall_width]})") do |c|
-    png_opts[:wall_width] = c
-  end
-
-  opts.separator ""
-  opts.separator "Other options:"
-
-  opts.on_tail("-v", "--version", "display the Theseus version and exit") do
-    maze = Theseus::OrthogonalMaze.generate(width: 20, height: 4)
-    s = maze.to_s(mode: :lines).strip
-    print s.gsub(/^/, "          ").sub(/^\s*/, "theseus --")
-
-    require 'theseus/version'
-    puts "--> v#{Theseus::Version::STRING}"
-    puts "a maze generator, renderer, and solver by Jamis Buck <jamis@jamisbuck.org>"
-    exit
-  end
-
-  opts.on_tail("-h", "--help", "this helpful list of options") do
-    puts opts
-    exit
-  end
-end.parse!
-
-# default width to height, and vice-versa
-maze_opts[:width] ||= maze_opts[:height]
-maze_opts[:height] ||= maze_opts[:width]
-
-if maze_opts[:mask].nil? && (maze_opts[:width].nil? || maze_opts[:height].nil?)
-  warn "You must specify either a mask (-m) or the maze dimensions(-w or -H)."
-  abort "Try --help for a full list of options."
-end
-
-if animate
-  abort "sparse cannot be used for animated mazes" if sparse > 0
-  abort "cannot animate unicursal mazes" if unicursal
-
-  png_opts[:background] = ChunkyPNG::Color.from_hex(png_opts[:background]) unless Fixnum === png_opts[:background]
-  solution = png_opts.delete(:solution)
-
-  if png_opts[:background] & 0xFF != 0xFF
-    warn "if you intend to make a movie out of the frames from the animation,"
-    warn "it is HIGHLY RECOMMENDED that you use a fully opaque background color."
-  end
-end
-
-if unicursal
-  unicursal_entrance = maze_opts.delete(:entrance)
-  maze_opts[:entrance] = [0,0]
-  maze_opts[:exit] = [0,0]
-end
-
-maze_opts[:mask] ||= Theseus::TransparentMask.new(maze_opts[:width], maze_opts[:height])
-maze_opts[:width] ||= maze_opts[:mask].width
-maze_opts[:height] ||= maze_opts[:mask].height
-maze = type_map[type].new(maze_opts)
-
-if unicursal && !maze.respond_to?(:to_unicursal)
-  abort "#{type} mazes do not support the -u (unicursal) option"
-end
-
-if animate
-  step = 0
-  maze.generate! do
-    if format == :ascii
-      system "clear"
-      puts maze.to_s(:mode => :unicode)
-      sleep 0.05
-    else
-      f = "%s-%04d.png" % [output, step]
-      step += 1
-      File.open(f, "w") { |io| io.write(maze.to(:png, png_opts)) }
-      print "."
-    end
-  end
-
-  if format == :ascii
-    system "clear"
-    puts maze.to_s(:mode => :unicode)
-  else
-    f = "%s-%04d.png" % [output, step]
-    File.open(f, "w") { |io| io.write(maze.to(:png, png_opts)) }
-    print "."
-
-    if solution
-      solver = maze.new_solver(type: solution)
-
-      while solver.step
-        path = solver.to_path(color: png_opts[:solution_color])
-
-        step += 1
-        f = "%s-%04d.png" % [output, step]
-        File.open(f, "w") { |io| io.write(maze.to(:png, png_opts.merge(paths: [path]))) }
-        print "."
-      end
-    end
-
-    puts
-    puts "done, %d frames written to %s-*.png" % [step+1, output]
-  end
-else
-  maze.generate!
-  sparse.times { maze.sparsify! }
-
-  if unicursal
-    enter_at = unicursal_entrance || [-1,0]
-    if enter_at[0] > 0 && enter_at[0] < width*2
-      exit_at = [enter_at[0]+1, enter_at[1]]
-    else
-      exit_at = [enter_at[0], enter_at[1]+1]
-    end
-    maze = maze.to_unicursal(entrance: enter_at, exit: exit_at)
-  end
-
-  if format == :ascii
-    puts maze.to_s(:mode => :unicode)
-  else
-    File.open(output + ".png", "w") { |io| io.write(maze.to(:png, png_opts)) }
-    puts "maze written to #{output}.png"
-  end
-end
+Theseus::CLI.run(ARGV)

data/lib/theseus/algorithms/base.rb

@@ -0,0 +1,31 @@
+module Theseus
+  module Algorithms
+    # A minimal abstract superclass for maze algorithms to descend
+    # from, mostly as a helper to provide some basic, common
+    # functionality.
+    class Base
+      # The maze object that the algorithm will operate on.
+      attr_reader :maze
+
+      # Create a new algorithm object that will operate on the
+      # given maze.
+      def initialize(maze, options={})
+        @maze = maze
+        @pending = true
+      end
+
+      # Returns true if the algorithm has not yet completed.
+      def pending?
+        @pending
+      end
+
+      # Execute a single step of the algorithm. Return true
+      # if the algorithm is still pending, or false if it has
+      # completed.
+      def step
+        return false unless pending?
+        do_step
+      end
+    end
+  end
+end

data/lib/theseus/algorithms/kruskal.rb

@@ -0,0 +1,81 @@
+require 'theseus/algorithms/base'
+
+module Theseus
+  module Algorithms
+    # Kruskal's algorithm is a means of finding a minimum spanning tree for a
+    # weighted graph. By changing how edges are selected, it becomes suitable
+    # for use as a maze generator.
+    #
+    # The mazes it generates tend to have a lot of short cul-de-sacs, which
+    # on the one hand makes the maze look "spiky", but on the other hand
+    # can potentially make the maze harder to solve.
+    #
+    # This implementation of Kruskal's algorithm does not support weave
+    # mazes.
+    class Kruskal < Base
+      class TreeSet #:nodoc:
+        attr_accessor :parent
+
+        def initialize
+          @parent = nil
+        end
+
+        def root
+          @parent ? @parent.root : self
+        end
+
+        def connected?(tree)
+          root == tree.root
+        end
+
+        def connect(tree)
+          tree.root.parent = self
+        end
+      end
+
+      def initialize(maze, options={}) #:nodoc:
+        super
+
+        if @maze.weave > 0
+          raise ArgumentError, "weave mazes cannot be generated with kruskal's algorithm"
+        end
+
+        @sets = Array.new(@maze.height) { Array.new(@maze.width) { TreeSet.new } }
+        @edges = []
+
+        maze.height.times do |y|
+          maze.row_length(y).times do |x|
+            next unless @maze.valid?(x, y)
+            @maze.potential_exits_at(x, y).each do |dir|
+              dx, dy = @maze.dx(dir), @maze.dy(dir)
+              if (dx < 0 || dy < 0) && @maze.valid?(x+dx, y+dy)
+                weight = rand(100) < @maze.randomness ? 0.5 + rand : 1
+                @edges << [x, y, dir, weight]
+              end
+            end
+          end
+        end
+
+        @edges = @edges.sort_by { |e| e.last }
+      end
+
+      def do_step #:nodoc:
+        until @edges.empty?
+          x, y, direction, _ = @edges.pop
+          nx, ny = x + @maze.dx(direction), y + @maze.dy(direction)
+
+          set1, set2 = @sets[y][x], @sets[ny][nx]
+          unless set1.connected?(set2)
+            set1.connect(set2)
+            @maze.apply_move_at(x, y, direction)
+            @maze.apply_move_at(nx, ny, @maze.opposite(direction))
+            return true
+          end
+        end
+
+        @pending = false
+        return false
+      end
+    end
+  end
+end

data/lib/theseus/algorithms/prim.rb

@@ -0,0 +1,81 @@
+require 'theseus/algorithms/base'
+
+module Theseus
+  module Algorithms
+    class Prim < Base
+      IN       = 0x10000 # indicate that a cell, though blank, is part of the IN set
+      FRONTIER = 0x20000 # indicate that a cell is part of the frontier set
+
+      def initialize(maze, options={}) #:nodoc:
+        super
+
+        if @maze.weave > 0
+          raise ArgumentError, "weave mazes cannot be generated with prim's algorithm"
+        end
+
+        @frontier = []
+
+        loop do
+          y = rand(@maze.height)
+          x = rand(@maze.row_length(y))
+          next unless @maze.valid?(x, y)
+
+          mark_cell(x, y)
+          break
+        end
+      end
+
+      # Iterates over each cell in the frontier space, yielding the coordinates
+      # of each one.
+      def each_frontier
+        @frontier.each do |x, y|
+          yield x, y
+        end
+      end
+
+      def do_step #:nodoc:
+        if rand(100) < @maze.randomness
+          x, y = @frontier.delete_at(rand(@frontier.length))
+        else
+          x, y = @frontier.pop
+        end
+
+        neighbors = find_neighbors_of(x, y)
+        direction, nx, ny = neighbors[rand(neighbors.length)]
+
+        @maze.apply_move_at(x, y, direction)
+        @maze.apply_move_at(nx, ny, @maze.opposite(direction))
+
+        mark_cell(x, y)
+
+        @pending = @frontier.any?
+      end
+
+      private
+
+      def mark_cell(x, y) #:nodoc:
+        @maze[x, y] |= IN
+        @maze[x, y] &= ~FRONTIER
+
+        @maze.potential_exits_at(x, y).each do |dir|
+          nx, ny = x + @maze.dx(dir), y + @maze.dy(dir)
+          if @maze.valid?(nx, ny) && @maze[nx, ny] == 0
+            @maze[nx, ny] |= FRONTIER
+            @frontier << [nx, ny]
+          end
+        end
+      end
+
+      def find_neighbors_of(x, y) #:nodoc:
+        list = []
+
+        @maze.potential_exits_at(x, y).each do |dir|
+          nx, ny = x + @maze.dx(dir), y + @maze.dy(dir)
+          list << [dir, nx, ny] if @maze.valid?(nx,ny) && @maze[nx, ny] & IN != 0
+        end
+
+        return list
+      end
+    end
+  end
+end