theseus 1.0.0

data/lib/theseus.rb

@@ -0,0 +1,6 @@
+require 'theseus/maze'
+
+require 'theseus/delta_maze'
+require 'theseus/orthogonal_maze'
+require 'theseus/sigma_maze'
+require 'theseus/upsilon_maze'

data/lib/theseus/delta_maze.rb

@@ -0,0 +1,45 @@
+require 'theseus/maze'
+
+module Theseus
+  # A "delta" maze is one in which the field is tesselated into triangles. Thus,
+  # each cell has three potential exits: east, west, and either north or south
+  # (depending on the orientation of the cell).
+  #
+  #      __  __  __
+  #    /\  /\  /\  /
+  #   /__\/__\/__\/
+  #   \  /\  /\  /\ 
+  #    \/__\/__\/__\ 
+  #    /\  /\  /\  /
+  #   /__\/__\/__\/
+  #   \  /\  /\  /\ 
+  #    \/__\/__\/__\ 
+  #   
+  #
+  # Delta mazes in Theseus do not support either weaving, or symmetry.
+  #
+  #   maze = Theseus::DeltaMaze.generate(width: 10)
+  #   puts maze
+  class DeltaMaze < Maze
+    def initialize(options={}) #:nodoc:
+      super
+      raise ArgumentError, "weaving is not supported for delta mazes" if @weave > 0
+    end
+
+    # Returns +true+ if the cell at (x,y) is oriented so the vertex is "up", or
+    # north. Cells for which this returns +true+ may have exits on the south border,
+    # and cells for which it returns +false+ may have exits on the north.
+    def points_up?(x, y)
+      (x + y) % 2 == height % 2
+    end
+
+    def potential_exits_at(x, y) #:nodoc:
+      vertical = points_up?(x, y) ? S : N
+
+      # list the vertical direction twice. Otherwise the horizontal direction (E/W)
+      # will be selected more often (66% of the time), resulting in mazes with a
+      # horizontal bias.
+      [vertical, vertical, E, W]
+    end
+  end
+end

data/lib/theseus/formatters/ascii.rb

@@ -0,0 +1,41 @@
+module Theseus
+  module Formatters
+    # ASCII formatters render a maze as ASCII art. The ASCII representation
+    # is intended mostly to give you a "quick look" at the maze, and will
+    # rarely suffice for showing more than an overview of the maze's shape.
+    #
+    # This is the abstract superclass of the ASCII formatters, and provides
+    # helpers for writing to a textual "canvas".
+    class ASCII
+      # The width of the canvas. This corresponds to, but is not necessarily the
+      # same as, the width of the maze.
+      attr_reader :width
+
+      # The height of the canvas. This corresponds to, but is not necessarily the
+      # same as, the height of the maze.
+      attr_reader :height
+
+      # Create a new ASCII canvas with the given width and height. The canvas is
+      # initially blank (set to whitespace).
+      def initialize(width, height)
+        @width, @height = width, height
+        @chars = Array.new(height) { Array.new(width, " ") }
+      end
+
+      # Returns the character at the given coordinates.
+      def [](x, y)
+        @chars[y][x]
+      end
+
+      # Sets the character at the given coordinates.
+      def []=(x, y, char)
+        @chars[y][x] = char
+      end
+
+      # Returns the canvas as a multiline string, suitable for displaying.
+      def to_s
+        @chars.map { |row| row.join }.join("\n")
+      end
+    end
+  end
+end

data/lib/theseus/formatters/ascii/delta.rb

@@ -0,0 +1,79 @@
+require 'theseus/formatters/ascii'
+
+module Theseus
+  module Formatters
+    class ASCII
+      # Renders a DeltaMaze to an ASCII representation, using 4 characters
+      # horizontally and 2 characters vertically to represent a single cell.
+      #
+      #          __
+      #        /\  /
+      #       /__\/
+      #      /\  /\ 
+      #     /__\/__\ 
+      #    /\  /\  /\ 
+      #   /__\/__\/__\ 
+      #
+      # You shouldn't ever need to instantiate this class directly. Rather, use
+      # DeltaMaze#to(:ascii) (or DeltaMaze#to_s to get the string directly).
+      class Delta < ASCII
+        # Returns a new Delta canvas for the given maze (which should be an
+        # instance of DeltaMaze). The +options+ parameter is not used.
+        #
+        # The returned object will be fully initialized, containing an ASCII
+        # representation of the given DeltaMaze.
+        def initialize(maze, options={})
+          super((maze.width + 1) * 2, maze.height * 2 + 1)
+
+          maze.height.times do |y|
+            py = y * 2
+            maze.row_length(y).times do |x|
+              cell = maze[x, y]
+              next if cell == 0
+
+              px = x * 2
+
+              if maze.points_up?(x, y)
+                if cell & Maze::W == 0
+                  self[px+1,py+1] = "/"
+                  self[px,py+2] = "/"
+                elsif y < 1
+                  self[px+1,py] = "_"
+                end
+
+                if cell & Maze::E == 0
+                  self[px+2,py+1] = "\\"
+                  self[px+3,py+2] = "\\"
+                elsif y < 1
+                  self[px+2,py] = "_"
+                end
+
+                if cell & Maze::S == 0
+                  self[px+1,py+2] = self[px+2,py+2] = "_"
+                end
+              else
+                if cell & Maze::W == 0
+                  self[px,py+1] = "\\"
+                  self[px+1,py+2] = "\\"
+                elsif x > 0 && maze[x-1,y] & Maze::S == 0
+                  self[px+1,py+2] = "_"
+                end
+
+                if cell & Maze::E == 0
+                  self[px+3,py+1] = "/"
+                  self[px+2,py+2] = "/"
+                elsif x < maze.row_length(y) && maze[x+1,y] & Maze::S == 0
+                  self[px+2,py+2] = "_"
+                end
+
+                if cell & Maze::N == 0
+                  self[px+1,py] = self[px+2,py] = "_"
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,156 @@
+# encoding: UTF-8
+
+require 'theseus/formatters/ascii'
+
+module Theseus
+  module Formatters
+    class ASCII
+      # Renders an OrthogonalMaze to an ASCII representation.
+      #
+      # The ASCII formatter for the OrthogonalMaze actually supports three different
+      # output types:
+      #
+      # [:plain]    Uses standard 7-bit ASCII characters. Width is 2x+1, height is
+      #             y+1. This mode cannot render weave mazes without significant
+      #             ambiguity.
+      # [:unicode]  Uses unicode characters to render cleaner lines. Width is
+      #             3x, height is 2y. This mode has sufficient detail to correctly
+      #             render mazes with weave!
+      # [:lines]    Draws passages as lines, using unicode characters. Width is
+      #             x, height is y. This mode can render weave mazes, but with some
+      #             ambiguity.
+      #
+      # The :plain mode is the default, but you can specify a different one using
+      # the :mode option.
+      #
+      # You shouldn't ever need to instantiate this class directly. Rather, use
+      # OrthogonalMaze#to(:ascii) (or OrthogonalMaze#to_s to get the string directly).
+      class Orthogonal < ASCII
+        # Returns the dimensions of the given maze, rendered in the given mode.
+        # The +mode+ must be +:plain+, +:unicode+, or +:lines+.
+        def self.dimensions_for(maze, mode)
+          case mode
+          when :plain, nil then 
+            [maze.width * 2 + 1, maze.height + 1]
+          when :unicode then
+            [maze.width * 3, maze.height * 2]
+          when :lines then
+            [maze.width, maze.height]
+          end
+        end
+
+        # Create and return a fully initialized ASCII canvas. The +options+
+        # parameter may specify a +:mode+ parameter, as described in the documentation
+        # for this class.
+        def initialize(maze, options={})
+          mode = options[:mode] || :plain
+
+          width, height = self.class.dimensions_for(maze, mode)
+          super(width, height)
+
+          maze.height.times do |y|
+            length = maze.row_length(y)
+            length.times do |x|
+              case mode
+              when :plain then draw_plain_cell(maze, x, y)
+              when :unicode then draw_unicode_cell(maze, x, y)
+              when :lines then draw_line_cell(maze, x, y)
+              end
+            end
+          end
+        end
+
+        private
+
+        def draw_plain_cell(maze, x, y) #:nodoc:
+          c = maze[x, y]
+          return if c == 0
+
+          px, py = x * 2, y
+
+          cnw = maze.valid?(x-1,y-1) ? maze[x-1,y-1] : 0
+          cn  = maze.valid?(x,y-1) ? maze[x,y-1] : 0
+          cne = maze.valid?(x+1,y-1) ? maze[x+1,y-1] : 0
+          cse = maze.valid?(x+1,y+1) ? maze[x+1,y+1] : 0
+          cs  = maze.valid?(x,y+1) ? maze[x,y+1] : 0
+          csw = maze.valid?(x-1,y+1) ? maze[x-1,y+1] : 0
+
+          if c & Maze::N == 0
+            self[px, py] = "_" if y == 0 || (cn == 0 && cnw == 0) || cnw & (Maze::E | Maze::S) == Maze::E
+            self[px+1, py] = "_"
+            self[px+2, py] = "_" if y == 0 || (cn == 0 && cne == 0) || cne & (Maze::W | Maze::S) == Maze::W
+          end
+
+          if c & Maze::S == 0
+            bottom = y+1 == maze.height
+            self[px, py+1] = "_" if bottom || (cs == 0 && csw == 0) || csw & (Maze::E | Maze::N) == Maze::E
+            self[px+1, py+1] = "_"
+            self[px+2, py+1] = "_" if bottom || (cs == 0 && cse == 0) || cse & (Maze::W | Maze::N) == Maze::W
+          end
+
+          self[px, py+1] = "|" if c & Maze::W == 0
+          self[px+2, py+1] = "|" if c & Maze::E == 0
+        end
+
+        UTF8_SPRITES = [
+          ["   ", "   "], # " "
+          ["│ │", "└─┘"], # "╵"
+          ["┌─┐", "│ │"], # "╷"
+          ["│ │", "│ │"], # "│",
+          ["┌──", "└──"], # "╶" 
+          ["│ └", "└──"], # "└" 
+          ["┌──", "│ ┌"], # "┌"
+          ["│ └", "│ ┌"], # "├" 
+          ["──┐", "──┘"], # "╴"
+          ["┘ │", "──┘"], # "┘"
+          ["──┐", "┐ │"], # "┐"
+          ["┘ │", "┐ │"], # "┤"
+          ["───", "───"], # "─"
+          ["┘ └", "───"], # "┴"
+          ["───", "┐ ┌"], # "┬"
+          ["┘ └", "┐ ┌"]  # "┼"
+        ]
+
+        def draw_unicode_cell(maze, x, y) #:nodoc:
+          cx, cy = 3 * x, 2 * y
+          cell = maze[x, y]
+
+          UTF8_SPRITES[cell & Maze::PRIMARY].each_with_index do |row, sy|
+            row.length.times do |sx|
+              char = row[sx]
+              self[cx+sx, cy+sy] = char
+            end
+          end
+
+          under = cell >> Maze::UNDER_SHIFT
+
+          if under & Maze::N != 0
+            self[cx,   cy] = "┴"
+            self[cx+2, cy] = "┴"
+          end
+
+          if under & Maze::S != 0
+            self[cx,   cy+1] = "┬"
+            self[cx+2, cy+1] = "┬"
+          end
+
+          if under & Maze::W != 0
+            self[cx, cy]   = "┤"
+            self[cx, cy+1] = "┤"
+          end
+
+          if under & Maze::E != 0
+            self[cx+2, cy]   = "├"
+            self[cx+2, cy+1] = "├"
+          end
+        end
+
+        UTF8_LINES = [" ", "╵", "╷", "│", "╶", "└", "┌", "├", "╴", "┘", "┐", "┤", "─", "┴", "┬", "┼"]
+
+        def draw_line_cell(maze, x, y) #:nodoc:
+          self[x, y] = UTF8_LINES[maze[x, y] & Maze::PRIMARY]
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,57 @@
+require 'theseus/formatters/ascii'
+
+module Theseus
+  module Formatters
+    class ASCII
+      # Renders a SigmaMaze to an ASCII representation, using 3 characters
+      # horizontally and 3 characters vertically to represent a single cell.
+      #    _   _   _
+      #   / \_/ \_/ \_
+      #   \_/ \_/ \_/ \ 
+      #   / \_/ \_/ \_/
+      #   \_/ \_/ \_/ \ 
+      #   / \_/ \_/ \_/
+      #   \_/ \_/ \_/ \ 
+      #   / \_/ \_/ \_/
+      #   \_/ \_/ \_/ \ 
+      #
+      # You shouldn't ever need to instantiate this class directly. Rather, use
+      # SigmaMaze#to(:ascii) (or SigmaMaze#to_s to get the string directly).
+      class Sigma < ASCII
+        # Returns a new Sigma canvas for the given maze (which should be an
+        # instance of SigmaMaze). The +options+ parameter is not used.
+        #
+        # The returned object will be fully initialized, containing an ASCII
+        # representation of the given SigmaMaze.
+        def initialize(maze, options={})
+          super(maze.width * 2 + 2, maze.height * 2 + 2)
+
+          maze.height.times do |y|
+            py = y * 2
+            maze.row_length(y).times do |x|
+              cell = maze[x, y]
+              next if cell == 0
+
+              px = x * 2
+
+              shifted = x % 2 != 0
+              ry = shifted ? py+1 : py
+
+              nw = shifted ? Maze::W : Maze::NW
+              ne = shifted ? Maze::E : Maze::NE
+              sw = shifted ? Maze::SW : Maze::W
+              se = shifted ? Maze::SE : Maze::E
+
+              self[px+1,ry]   = "_" if cell & Maze::N == 0
+              self[px,ry+1]   = "/" if cell & nw == 0
+              self[px+2,ry+1] = "\\" if cell & ne == 0
+              self[px,ry+2]   = "\\" if cell & sw == 0
+              self[px+1,ry+2] = "_" if cell & Maze::S == 0
+              self[px+2,ry+2] = "/" if cell & se == 0
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/theseus/formatters/ascii/upsilon.rb

@@ -0,0 +1,67 @@
+require 'theseus/formatters/ascii'
+
+module Theseus
+  module Formatters
+    class ASCII
+      # Renders an UpsilonMaze to an ASCII representation, using 3 characters
+      # horizontally and 4 characters vertically to represent a single octagonal
+      # cell, and 3 characters horizontally and 2 vertically to represent a square
+      # cell.
+      #    _   _   _  
+      #   / \_/ \_/ \ 
+      #   | |_| |_| |
+      #   \_/ \_/ \_/ 
+      #   |_| |_| |_|
+      #   / \_/ \_/ \ 
+      #
+      # You shouldn't ever need to instantiate this class directly. Rather, use
+      # UpsilonMaze#to(:ascii) (or UpsilonMaze#to_s to get the string directly).
+      class Upsilon < ASCII
+        # Returns a new Sigma canvas for the given maze (which should be an
+        # instance of SigmaMaze). The +options+ parameter is not used.
+        #
+        # The returned object will be fully initialized, containing an ASCII
+        # representation of the given SigmaMaze.
+        def initialize(maze, options={})
+          super(maze.width * 2 + 1, maze.height * 2 + 3)
+
+          maze.height.times do |y|
+            py = y * 2
+            maze.row_length(y).times do |x|
+              cell = maze[x, y]
+              next if cell == 0
+
+              px = x * 2
+
+              if (x + y) % 2 == 0
+                draw_octogon_cell(px, py, cell)
+              else
+                draw_square_cell(px, py, cell)
+              end
+            end
+          end
+        end
+
+        private
+
+        def draw_octogon_cell(px, py, cell) #:nodoc:
+          self[px+1, py]   = "_" if cell & Maze::N == 0
+          self[px, py+1]   = "/" if cell & Maze::NW == 0
+          self[px+2, py+1] = "\\" if cell & Maze::NE == 0
+          self[px, py+2]   = "|" if cell & Maze::W == 0
+          self[px+2, py+2] = "|" if cell & Maze::E == 0
+          self[px, py+3]   = "\\" if cell & Maze::SW == 0
+          self[px+1, py+3] = "_" if cell & Maze::S == 0
+          self[px+2, py+3] = "/" if cell & Maze::SE == 0
+        end
+
+        def draw_square_cell(px, py, cell) #:nodoc:
+          self[px+1, py+1] = "_" if cell & Maze::N == 0
+          self[px, py+2]   = "|" if cell & Maze::W == 0
+          self[px+1, py+2] = "_" if cell & Maze::S == 0
+          self[px+2, py+2] = "|" if cell & Maze::E == 0
+        end
+      end
+    end
+  end
+end